claude-flow-novice 2.18.40 → 2.19.1

package/.claude/skills/{cfn-local-ruvector-accelerator → cfn-codesearch}/query-local.sh

@@ -1,11 +1,11 @@
 #!/bin/bash
-# query-local.sh - Query local RuVector for patterns using Rust binary
+# query-local.sh - Query local CodeSearch 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)"
-DB_PATH="$HOME/.local/share/ruvector/index_v2.db"
+DB_PATH="$HOME/.local/share/codesearch/index_v2.db"
 
 # Parse arguments
 PATTERN=""
@@ -50,7 +50,7 @@ if [[ "$HELP" == true ]] || [[ -z "$PATTERN" ]]; then
     cat << EOF
 Usage: query-local [OPTIONS] PATTERN
 
-Query local RuVector database for code patterns
+Query local CodeSearch database for code patterns
 
 Arguments:
   PATTERN               Search pattern (entity name or partial match)
@@ -86,8 +86,8 @@ fi
 
 # 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"
+    echo "❌ Error: CodeSearch database not found at $DB_PATH"
+    echo "   Run: local-codesearch index --path /your/project"
     exit 1
 fi
 
@@ -118,7 +118,7 @@ if [[ -z "$RESULTS" ]]; then
     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"
+    echo "   - Reindex if needed: local-codesearch index --path /your/project"
 else
     echo "$RESULTS"
     echo ""

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

@@ -43,7 +43,7 @@ impl CleanupCommand {
         }
 
         let search_engine = SearchEngine::new(&self.project_dir)?;
-        let store = SqliteStore::new(&self.project_dir.join(".ruvector").join("index.db"))?;
+        let store = SqliteStore::new(&self.project_dir.join(".codesearch").join("index.db"))?;
 
         // Check if there's anything to clean
         let stats = store.get_stats()?;

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

@@ -1,4 +1,4 @@
-//! # RuVector Index Command
+//! # CodeSearch Index Command
 //!
 //! ## IMPORTANT: Run from PROJECT ROOT
 //!
@@ -8,7 +8,7 @@
 //! ## Recommended Usage:
 //! ```bash
 //! cd /path/to/project-root
-//! local-ruvector index --path . --types rs,ts,js,json,md,sh --force
+//! local-codesearch index --path . --types rs,ts,js,json,md,sh --force
 //! ```
 //!
 //! ## Supported File Types (default):
@@ -23,7 +23,7 @@
 //! - Cache: .cache, __pycache__, .pytest_cache, .mypy_cache, .ruff_cache, coverage, .nyc_output
 //! - Virtual envs: .venv, venv, env
 //! - IaC: .terraform, .serverless, .aws-sam
-//! - Project-specific: .artifacts, .ruvector, .archive, archive, .archived, archived
+//! - Project-specific: .artifacts, .codesearch, .archive, archive, .archived, archived
 //! - Backups/temp: backups, .backups, backup, tmp, .tmp, temp, logs
 //! - Test artifacts: __snapshots__, __mocks__, playwright-report, test-results
 //! - Doc builds: _site, .docusaurus, site
@@ -39,7 +39,7 @@
 //!
 //! ## Multi-Project Isolation:
 //! - Each project root is isolated via project_root column in v2 schema
-//! - Centralized database at ~/.local/share/ruvector/index_v2.db
+//! - Centralized database at ~/.local/share/codesearch/index_v2.db
 //! - Queries are scoped to the project root passed during indexing
 
 use anyhow::{Result, Context, anyhow};
@@ -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.
@@ -120,7 +121,7 @@ const EXCLUDED_DIRS: &[&str] = &[
 
     // Project-specific
     ".artifacts",        // CFN Loop artifacts
-    ".ruvector",         // RuVector local index (avoid self-indexing)
+    ".codesearch",         // CodeSearch local index (avoid self-indexing)
     ".archive",          // Archived/deprecated code
     "archive",           // Archive directories
     ".archived",         // Archived code (alternate naming)
@@ -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/index_ast.rs

@@ -62,8 +62,8 @@ impl AstIndexCommand {
         patterns: Option<Vec<String>>,
         force: bool,
     ) -> Result<Self> {
-        // Use local .ruvector for embeddings cache, but centralized DB for entities
-        let index_path = project_dir.join(".ruvector");
+        // Use local .codesearch for embeddings cache, but centralized DB for entities
+        let index_path = project_dir.join(".codesearch");
         fs::create_dir_all(&index_path)?;
 
         // Embeddings are cached locally per project
@@ -188,7 +188,7 @@ impl AstIndexCommand {
                     return false;
                 }
 
-                // Skip .ruvector directory
+                // Skip .codesearch directory
                 if e.path().starts_with(&self.index_path) {
                     return false;
                 }

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!("CodeSearch 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)
-                .context("Failed to create RuVector directory")?;
-            fs::create_dir_all(ruvector_dir.join("embeddings"))
+        if !codesearch_dir.exists() {
+            info!("Creating centralized CodeSearch directory: {}", codesearch_dir.display());
+            fs::create_dir_all(&codesearch_dir)
+                .context("Failed to create CodeSearch directory")?;
+            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 CodeSearch 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/migration.rs

@@ -7,7 +7,7 @@ use crate::migration_tx::MigrationWithTx;
 
 #[derive(Debug, Clone)]
 pub enum SourceType {
-    RuVectorPython,
+    CodeSearchPython,
     CodeBERT,
     Whoosh,
     Elastic,
@@ -37,7 +37,7 @@ impl MigrationCommand {
 
     pub fn execute(&self) -> Result<()> {
         match self.source_type {
-            SourceType::RuVectorPython => self.migrate_from_python(),
+            SourceType::CodeSearchPython => self.migrate_from_python(),
             SourceType::CodeBERT => self.migrate_from_codebert(),
             SourceType::Whoosh => self.migrate_from_whoosh(),
             SourceType::Elastic => self.migrate_from_elastic(),
@@ -46,7 +46,7 @@ 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");
+        let db_path = self.project_dir.join(".codesearch/index_v2.db");
 
         // Ensure database directory exists
         std::fs::create_dir_all(db_path.parent().unwrap())
@@ -59,7 +59,7 @@ impl MigrationCommand {
 
         // Use the transaction-aware migration
         match self.source_type {
-            SourceType::RuVectorPython => {
+            SourceType::CodeSearchPython => {
                 MigrationWithTx::migrate_v1_to_v2_atomic(&mut conn)?;
                 MigrationWithTx::validate_migration(&mut conn)?;
             }
@@ -74,7 +74,7 @@ impl MigrationCommand {
     }
 
     fn migrate_from_python(&self) -> Result<()> {
-        println!("⚠️  Migration from Python RuVector not yet implemented");
+        println!("⚠️  Migration from Python CodeSearch not yet implemented");
         if self.dry_run {
             println!("Would migrate from: {}", self.source_path.display());
         }

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 {