claude-flow-novice 2.18.39 → 2.19.0

package/.claude/skills/{cfn-local-ruvector-accelerator → cfn-codesearch}/src/cli/index.rs

@@ -63,7 +63,8 @@ use crate::extractors::text_fallback::TextFallbackExtractor;
 use crate::store_v2::{StoreV2, Entity as StoreEntity, Reference as StoreReference, TypeUsage};
 use crate::schema_v2::{EntityKind, RefKind, Visibility};
 use crate::path_validator;
-use local_ruvector::paths::{get_ruvector_dir, get_database_path};
+use codesearch::store_pgvector::PgvectorStore;
+use codesearch::paths::{get_codesearch_dir, get_database_path};
 // V1 index is deprecated - all operations use V2 (index_v2.db)
 
 /// Directories to exclude from indexing.
@@ -246,11 +247,82 @@ pub struct IndexCommand {
     search_engine: SearchEngine,
     store: SqliteStore,
     store_v2: StoreV2,
+    pgvector_store: Option<PgvectorStore>,
+    tokio_runtime: Option<tokio::runtime::Runtime>,
     rust_extractor: RustExtractor,
     typescript_extractor: TypeScriptExtractor,
     text_fallback_extractor: TextFallbackExtractor,
 }
 
+/// Extract doc comments from a signature string.
+/// Supports Rust-style (///, //!) and JSDoc-style (/** */) comments.
+fn extract_doc_comment(signature: &str) -> Option<String> {
+    let lines: Vec<&str> = signature.lines().collect();
+    let mut doc_lines: Vec<String> = Vec::new();
+    let mut in_jsdoc = false;
+
+    for line in &lines {
+        let trimmed = line.trim();
+
+        // Handle JSDoc-style comments (/** ... */)
+        if trimmed.starts_with("/**") {
+            let after_open = trimmed.strip_prefix("/**").unwrap_or("").trim();
+            // Check if it's a single-line JSDoc (/** content */)
+            if after_open.ends_with("*/") {
+                let content = after_open.strip_suffix("*/").unwrap_or(after_open).trim();
+                if !content.is_empty() {
+                    doc_lines.push(content.to_string());
+                }
+                // Single-line, don't enter jsdoc mode
+                continue;
+            }
+            // Multi-line JSDoc
+            in_jsdoc = true;
+            if !after_open.is_empty() {
+                doc_lines.push(after_open.to_string());
+            }
+            continue;
+        }
+
+        if in_jsdoc {
+            if trimmed.contains("*/") {
+                in_jsdoc = false;
+                // Extract content before */
+                let content = trimmed.strip_suffix("*/").unwrap_or(trimmed)
+                    .trim_start_matches('*').trim();
+                if !content.is_empty() {
+                    doc_lines.push(content.to_string());
+                }
+            } else {
+                // Middle lines of JSDoc (usually start with *)
+                let content = trimmed.trim_start_matches('*').trim();
+                if !content.is_empty() {
+                    doc_lines.push(content.to_string());
+                }
+            }
+            continue;
+        }
+
+        // Handle Rust-style doc comments (/// or //!)
+        if trimmed.starts_with("///") {
+            let content = trimmed.strip_prefix("///").unwrap_or("").trim();
+            doc_lines.push(content.to_string());
+        } else if trimmed.starts_with("//!") {
+            let content = trimmed.strip_prefix("//!").unwrap_or("").trim();
+            doc_lines.push(content.to_string());
+        } else if !doc_lines.is_empty() {
+            // Stop when we hit a non-doc-comment line after collecting some
+            break;
+        }
+    }
+
+    if doc_lines.is_empty() {
+        None
+    } else {
+        Some(doc_lines.join("\n"))
+    }
+}
+
 impl IndexCommand {
     pub fn new(
         project_dir: &Path,
@@ -258,13 +330,33 @@ impl IndexCommand {
         file_types: Vec<String>,
         patterns: Option<Vec<String>>,
         force: bool,
+        pg_url: Option<&str>,
     ) -> Result<Self> {
-        let index_path = get_ruvector_dir()?;
+        let index_path = get_codesearch_dir()?;
         let embeddings_manager = EmbeddingsManager::new(&index_path)?;
         let search_engine = SearchEngine::new(&index_path)?;
         let store = SqliteStore::new(&index_path.join("index.db"))?;
         let store_v2 = StoreV2::new(&get_database_path()?)?;
 
+        // Initialize pgvector store and runtime if connection URL provided
+        let (pgvector_store, tokio_runtime) = if let Some(url) = pg_url {
+            info!("Initializing pgvector store with URL: {}", url);
+            let rt = tokio::runtime::Runtime::new()?;
+            match rt.block_on(PgvectorStore::new(url)) {
+                Ok(store) => {
+                    info!("Successfully connected to pgvector");
+                    (Some(store), Some(rt))
+                }
+                Err(e) => {
+                    warn!("Failed to connect to pgvector: {}. Using SQLite only.", e);
+                    (None, None)
+                }
+            }
+        } else {
+            info!("No pg_url provided, using SQLite only");
+            (None, None)
+        };
+
         let source_path = if path.as_os_str().is_empty() || path == Path::new(".") {
             project_dir.to_path_buf()
         } else {
@@ -282,6 +374,8 @@ impl IndexCommand {
             search_engine,
             store,
             store_v2,
+            pgvector_store,
+            tokio_runtime,
             rust_extractor: RustExtractor::new()?,
             typescript_extractor: TypeScriptExtractor::new()?,
             text_fallback_extractor: TextFallbackExtractor::new()?,
@@ -476,11 +570,75 @@ impl IndexCommand {
 
         let embeddings = self.generate_entity_embeddings(&extraction_result.entities)?;
 
-        // Store embeddings in entity_embeddings table
+        // Store embeddings in SQLite entity_embeddings table (metadata)
         for (entity_id, embedding) in entity_ids.iter().zip(embeddings.iter()) {
             self.store_v2.store_embedding(*entity_id, embedding, "text-embedding-3-small")?;
         }
 
+        // Store embeddings in pgvector if available
+        if let Some(ref pgvector_store) = self.pgvector_store {
+            if let Some(ref rt) = self.tokio_runtime {
+                let project_root_str = self.project_dir.to_string_lossy().to_string();
+
+                // Build entities the same way store_entities does
+                for (i, entity) in extraction_result.entities.iter().enumerate() {
+                    let store_entity = codesearch::store_v2::Entity {
+                        id: entity_ids[i],
+                        kind: match entity.kind {
+                            crate::extractors::EntityKind::Function => codesearch::schema_v2::EntityKind::Function,
+                            crate::extractors::EntityKind::Method => codesearch::schema_v2::EntityKind::Method,
+                            crate::extractors::EntityKind::Constructor => codesearch::schema_v2::EntityKind::Constructor,
+                            crate::extractors::EntityKind::Getter => codesearch::schema_v2::EntityKind::Getter,
+                            crate::extractors::EntityKind::Setter => codesearch::schema_v2::EntityKind::Setter,
+                            crate::extractors::EntityKind::Class => codesearch::schema_v2::EntityKind::Class,
+                            crate::extractors::EntityKind::Interface => codesearch::schema_v2::EntityKind::Interface,
+                            crate::extractors::EntityKind::Struct => codesearch::schema_v2::EntityKind::Struct,
+                            crate::extractors::EntityKind::Enum => codesearch::schema_v2::EntityKind::Enum,
+                            crate::extractors::EntityKind::Trait => codesearch::schema_v2::EntityKind::Trait,
+                            crate::extractors::EntityKind::TypeAlias => codesearch::schema_v2::EntityKind::TypeAlias,
+                            crate::extractors::EntityKind::Module => codesearch::schema_v2::EntityKind::Module,
+                            crate::extractors::EntityKind::Namespace => codesearch::schema_v2::EntityKind::Namespace,
+                            crate::extractors::EntityKind::Variable => codesearch::schema_v2::EntityKind::Variable,
+                            crate::extractors::EntityKind::Constant => codesearch::schema_v2::EntityKind::Constant,
+                            crate::extractors::EntityKind::Parameter => codesearch::schema_v2::EntityKind::Parameter,
+                            crate::extractors::EntityKind::Import => codesearch::schema_v2::EntityKind::Import,
+                        },
+                        name: entity.name.clone(),
+                        signature: Some(entity.signature.clone()),
+                        visibility: match entity.visibility {
+                            crate::extractors::Visibility::Public => codesearch::schema_v2::Visibility::Public,
+                            crate::extractors::Visibility::Private => codesearch::schema_v2::Visibility::Private,
+                            crate::extractors::Visibility::Protected => codesearch::schema_v2::Visibility::Protected,
+                            crate::extractors::Visibility::Internal => codesearch::schema_v2::Visibility::Internal,
+                            crate::extractors::Visibility::FilePrivate => codesearch::schema_v2::Visibility::FilePrivate,
+                        },
+                        parent_id: None,
+                        file_path: file_path.to_string_lossy().to_string(),
+                        line_number: entity.line as i64,
+                        column_number: Some(entity.column as i64),
+                        doc_comment: extract_doc_comment(&entity.signature),
+                        attributes: None,
+                        metadata: Some(serde_json::to_string(&entity.metadata)?),
+                        project_root: project_root_str.clone(),
+                        created_at: chrono::Utc::now(),
+                        updated_at: chrono::Utc::now(),
+                    };
+
+                    // Use the stored runtime (created once in new())
+                    match rt.block_on(pgvector_store.store_entity_with_embedding(
+                        &store_entity,
+                        &embeddings[i],
+                        &project_root_str,
+                    )) {
+                        Ok(_) => debug!("Stored entity in pgvector: {}", store_entity.name),
+                        Err(e) => warn!("Failed to store entity in pgvector: {:?}", e),
+                    }
+                }
+            } else {
+                warn!("pgvector_store available but tokio_runtime is None - this is a bug");
+            }
+        }
+
         {
             let mut s = stats.write().unwrap();
             s.files_processed += 1;
@@ -555,7 +713,7 @@ impl IndexCommand {
                 file_path: file_path.to_string_lossy().to_string(),
                 line_number: entity.line as i64,
                 column_number: Some(entity.column as i64),
-                doc_comment: None,
+                doc_comment: extract_doc_comment(&entity.signature),
                 attributes: None,
                 metadata: Some(serde_json::to_string(&entity.metadata)?),
                 project_root: project_root_str.to_string(),
@@ -721,4 +879,75 @@ impl IndexCommand {
         
         Ok(format!("{:x}", hasher.finalize()))
     }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_extract_rust_doc_comment() {
+        let signature = r#"/// Create a new Rust extractor
+pub fn new() -> Self"#;
+        let doc = extract_doc_comment(signature);
+        assert_eq!(doc, Some("Create a new Rust extractor".to_string()));
+    }
+
+    #[test]
+    fn test_extract_rust_multiline_doc_comment() {
+        let signature = r#"/// Create a new store
+/// This is the main entry point
+pub fn new() -> Self"#;
+        let doc = extract_doc_comment(signature);
+        assert_eq!(doc, Some("Create a new store\nThis is the main entry point".to_string()));
+    }
+
+    #[test]
+    fn test_extract_rust_inner_doc_comment() {
+        let signature = r#"//! Module documentation
+//! This module handles storage
+pub mod store"#;
+        let doc = extract_doc_comment(signature);
+        assert_eq!(doc, Some("Module documentation\nThis module handles storage".to_string()));
+    }
+
+    #[test]
+    fn test_extract_jsdoc_comment() {
+        let signature = r#"/**
+ * Create a new instance
+ * @param name The name
+ */
+function create(name: string)"#;
+        let doc = extract_doc_comment(signature);
+        assert_eq!(doc, Some("Create a new instance\n@param name The name".to_string()));
+    }
+
+    #[test]
+    fn test_extract_jsdoc_single_line() {
+        let signature = r#"/** Quick summary */
+function test()"#;
+        let doc = extract_doc_comment(signature);
+        assert_eq!(doc, Some("Quick summary".to_string()));
+    }
+
+    #[test]
+    fn test_no_doc_comment() {
+        let signature = r#"pub fn new() -> Self"#;
+        let doc = extract_doc_comment(signature);
+        assert_eq!(doc, None);
+    }
+
+    #[test]
+    fn test_empty_signature() {
+        let doc = extract_doc_comment("");
+        assert_eq!(doc, None);
+    }
+
+    #[test]
+    fn test_regular_comment_not_extracted() {
+        let signature = r#"// This is a regular comment
+pub fn new() -> Self"#;
+        let doc = extract_doc_comment(signature);
+        assert_eq!(doc, None);
+    }
 }

package/.claude/skills/{cfn-local-ruvector-accelerator → cfn-codesearch}/src/cli/init.rs

@@ -8,7 +8,7 @@ use crate::embeddings::EmbeddingsManager;
 use crate::search_engine::SearchEngine;
 use crate::sqlite_store::SqliteStore;
 use crate::migration_v2::MigrationV2;
-use local_ruvector::paths::{get_ruvector_dir, get_database_path};
+use codesearch::paths::{get_codesearch_dir, get_database_path};
 // V1 index is deprecated - all operations use V2 (index_v2.db)
 
 pub struct InitCommand {
@@ -42,9 +42,9 @@ impl InitCommand {
         let _ = rusqlite::Connection::open_in_memory()
             .context("SQLite is not available")?;
 
-        let ruvector_dir = get_ruvector_dir()?;
-        if ruvector_dir.exists() {
-            info!("RuVector already initialized at: {}", ruvector_dir.display());
+        let codesearch_dir = get_codesearch_dir()?;
+        if codesearch_dir.exists() {
+            info!("RuVector already initialized at: {}", codesearch_dir.display());
         }
 
         info!("Environment check passed");
@@ -52,24 +52,24 @@ impl InitCommand {
     }
 
     pub fn execute(&self) -> Result<()> {
-        let ruvector_dir = get_ruvector_dir()?;
+        let codesearch_dir = get_codesearch_dir()?;
         
         // Create directory if doesn't exist (idempotent)
-        if !ruvector_dir.exists() {
-            info!("Creating centralized RuVector directory: {}", ruvector_dir.display());
-            fs::create_dir_all(&ruvector_dir)
+        if !codesearch_dir.exists() {
+            info!("Creating centralized RuVector directory: {}", codesearch_dir.display());
+            fs::create_dir_all(&codesearch_dir)
                 .context("Failed to create RuVector directory")?;
-            fs::create_dir_all(ruvector_dir.join("embeddings"))
+            fs::create_dir_all(codesearch_dir.join("embeddings"))
                 .context("Failed to create embeddings directory")?;
             // V1 index directory no longer created - using centralized V2 database
-            fs::create_dir_all(ruvector_dir.join("cache"))
+            fs::create_dir_all(codesearch_dir.join("cache"))
                 .context("Failed to create cache directory")?;
         } else {
-            info!("Using existing centralized RuVector directory: {}", ruvector_dir.display());
+            info!("Using existing centralized RuVector directory: {}", codesearch_dir.display());
         }
         
         // Create configuration file if missing
-        if !ruvector_dir.join("config.json").exists() {
+        if !codesearch_dir.join("config.json").exists() {
             self.create_config()?;
         }
         
@@ -83,7 +83,7 @@ impl InitCommand {
         }
         
         // Initialize embeddings manager
-        if !ruvector_dir.join("embeddings").exists() {
+        if !codesearch_dir.join("embeddings").exists() {
             self.initialize_embeddings()?;
         }
         
@@ -95,8 +95,8 @@ impl InitCommand {
     }
 
     fn create_config(&self) -> Result<()> {
-        let ruvector_dir = get_ruvector_dir()?;
-        let config_path = ruvector_dir.join("config.json");
+        let codesearch_dir = get_codesearch_dir()?;
+        let config_path = codesearch_dir.join("config.json");
 
         let config = json!({
             "version": "1.0.0",
@@ -129,7 +129,7 @@ impl InitCommand {
 
         // Initialize Schema V2 using CREATE TABLE IF NOT EXISTS (always safe)
         let mut conn = rusqlite::Connection::open(&db_path)?;
-        local_ruvector::schema_v2::SchemaV2::initialize(&conn)?;
+        codesearch::schema_v2::SchemaV2::initialize(&conn)?;
 
         // Run v2 migration to add multi-project isolation
         info!("Running database migrations...");
@@ -163,14 +163,14 @@ impl InitCommand {
         let conn = rusqlite::Connection::open(&db_path)?;
         
         // Re-run schema initialization (uses IF NOT EXISTS)
-        local_ruvector::schema_v2::SchemaV2::initialize(&conn)?;
+        codesearch::schema_v2::SchemaV2::initialize(&conn)?;
         
         debug!("Schema tables recreated (non-destructive)");
         Ok(())
     }
 
     fn initialize_embeddings(&self) -> Result<()> {
-        let embeddings_dir = get_ruvector_dir()?;
+        let embeddings_dir = get_codesearch_dir()?;
         let _ = EmbeddingsManager::new(&embeddings_dir)?;
 
         debug!("Embeddings manager initialized");

package/.claude/skills/{cfn-local-ruvector-accelerator → cfn-codesearch}/src/cli/query.rs

@@ -9,6 +9,8 @@ use serde::Serialize;
 use crate::query_v2::{QueryV2, SearchResult};
 use crate::paths::get_database_path;
 use crate::path_validator;
+use codesearch::store_pgvector::PgvectorStore;
+use codesearch::embeddings::EmbeddingsManager;
 
 #[derive(Debug, Clone)]
 pub enum OutputFormat {
@@ -27,11 +29,12 @@ pub struct QueryConfig {
     pub file_filter: Option<String>,
 }
 
-#[derive(Debug)]
 pub struct QueryCommand {
     project_dir: PathBuf,
     config: QueryConfig,
     query_v2: QueryV2,
+    pgvector_store: Option<PgvectorStore>,
+    embeddings_manager: Option<EmbeddingsManager>,
 }
 
 impl QueryCommand {
@@ -43,6 +46,7 @@ impl QueryCommand {
         output_format: OutputFormat,
         context_lines: usize,
         file_filter: Option<String>,
+        pg_url: Option<&str>,
     ) -> Result<Self> {
         // Canonicalize project_dir at the start for security
         let canonical_project_dir = path_validator::canonicalize(project_dir)?;
@@ -51,6 +55,28 @@ impl QueryCommand {
         let db_path = get_database_path()?;
         let query_v2 = QueryV2::new(&db_path)?;
 
+        // Initialize pgvector store if connection URL provided
+        let (pgvector_store, embeddings_manager) = if let Some(url) = pg_url {
+            info!("Initializing pgvector store for queries");
+            let rt = tokio::runtime::Runtime::new()?;
+            match rt.block_on(PgvectorStore::new(url)) {
+                Ok(store) => {
+                    info!("Successfully connected to pgvector");
+                    // Need embeddings manager to generate query embeddings
+                    let index_path = crate::paths::get_codesearch_dir()?;
+                    let embeddings_mgr = EmbeddingsManager::new(&index_path)?;
+                    (Some(store), Some(embeddings_mgr))
+                }
+                Err(e) => {
+                    warn!("Failed to connect to pgvector: {}. Using SQLite only.", e);
+                    (None, None)
+                }
+            }
+        } else {
+            info!("No pg_url provided, using SQLite only");
+            (None, None)
+        };
+
         Ok(Self {
             project_dir: canonical_project_dir,
             config: QueryConfig {
@@ -62,6 +88,8 @@ impl QueryCommand {
                 file_filter,
             },
             query_v2,
+            pgvector_store,
+            embeddings_manager,
         })
     }
 
@@ -72,8 +100,41 @@ impl QueryCommand {
         let max_results = self.config.max_results.unwrap_or(10);
         let threshold = self.config.threshold.unwrap_or(0.3);
 
-        // Perform search with project root isolation
-        let results = self.query_v2.search(&self.config.query, max_results, threshold, &self.project_dir)?;
+        // Perform search - use pgvector if available, otherwise SQLite
+        let results: Vec<SearchResult> = if let (Some(ref pgvector_store), Some(ref embeddings_mgr)) =
+            (&self.pgvector_store, &self.embeddings_manager) {
+            info!("Using pgvector for semantic search");
+
+            // Generate embedding for query
+            let query_texts: Vec<String> = vec![self.config.query.clone()];
+            let query_embeddings: Vec<Vec<f32>> = embeddings_mgr.generate_embeddings(&query_texts)?;
+            let query_embedding: &[f32] = &query_embeddings[0];
+
+            // Search pgvector
+            let rt = tokio::runtime::Runtime::new()?;
+            let project_root_str = self.project_dir.to_string_lossy().to_string();
+            let pg_results = rt.block_on(
+                pgvector_store.search_similar(
+                    query_embedding,
+                    max_results,
+                    threshold,
+                    Some(&project_root_str),
+                )
+            )?;
+
+            // Convert pgvector SearchResult to query_v2 SearchResult
+            pg_results.into_iter().map(|r| SearchResult {
+                entity_kind: r.entity_kind,
+                entity_name: r.entity_name,
+                file_path: r.file_path,
+                similarity: r.similarity,
+                line_start: Some(r.line_number),
+                line_end: None,
+            }).collect()
+        } else {
+            info!("Using SQLite for search");
+            self.query_v2.search(&self.config.query, max_results, threshold, &self.project_dir)?
+        };
 
         // Filter by file if specified
         let final_results: Vec<SearchResult> = if let Some(ref file_filter) = self.config.file_filter {

package/.claude/skills/{cfn-local-ruvector-accelerator → cfn-codesearch}/src/embeddings.rs

@@ -108,12 +108,26 @@ impl EmbeddingsManager {
         }
 
         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);
+        // Check if we're already in a tokio runtime
+        match tokio::runtime::Handle::try_current() {
+            Ok(handle) => {
+                // We're in a runtime, use it
+                for chunk in texts.chunks(self.config.batch_size) {
+                    let embeddings = handle.block_on(self.call_openai_api(chunk))
+                        .context("Failed to generate embeddings from OpenAI API")?;
+                    all_embeddings.extend(embeddings);
+                }
+            }
+            Err(_) => {
+                // Not in a runtime, create one
+                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());

package/.claude/skills/{cfn-local-ruvector-accelerator → cfn-codesearch}/src/lib.rs

@@ -1,7 +1,7 @@
-//! Local RuVector Accelerator - Fast pattern storage and search
+//! CodeSearch - Fast semantic code search with AST indexing
 //!
-//! This crate provides local storage and search capabilities for code patterns
-//! using vector embeddings and SQLite.
+//! This crate provides storage and search capabilities for code patterns
+//! using vector embeddings. Supports SQLite (default) and pgvector backends.
 
 pub mod embeddings;
 pub mod sqlite_store;
@@ -15,6 +15,7 @@ pub mod schema_v2;
 pub mod query_v2;
 pub mod migration_v2;
 pub mod migration_tx;
+pub mod store_pgvector;
 
 #[cfg(test)]
 mod transaction_tests;
@@ -23,10 +24,11 @@ mod transaction_tests;
 pub use embeddings::EmbeddingsManager;
 pub use sqlite_store::SqliteStore;
 pub use search_engine::SearchEngine;
-pub use paths::{get_ruvector_dir, get_database_path};
+pub use paths::{get_codesearch_dir, get_database_path};
 // V1 index functions are deprecated - use V2 via get_database_path()
 pub use store_v2::StoreV2;
 pub use store_v2_tx::StoreV2WithTx;
 pub use schema_v2::SchemaV2;
 pub use query_v2::QueryV2;
 pub use migration_v2::MigrationV2;
+pub use store_pgvector::PgvectorStore;