claude-flow-novice 2.18.39 → 2.19.0

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

@@ -24,10 +24,14 @@ mod query_v2;
 mod transaction_tests;
 
 use cli::*;
+
+/// Default PostgreSQL connection for pgvector
+const DEFAULT_PG_URL: &str = "postgresql://postgres:postgres@localhost:5433/daily_platform";
+
 #[derive(Parser)]
-#[command(name = "local-ruvector")]
-#[command(about = "Local RuVector Accelerator - Fast pattern storage and search", long_about = None)]
-#[command(version = "1.0.0")]
+#[command(name = "codesearch")]
+#[command(about = "CodeSearch - Fast semantic code search with pgvector", long_about = None)]
+#[command(version = "0.2.0")]
 struct Cli {
     #[command(subcommand)]
     command: Commands,
@@ -36,6 +40,10 @@ struct Cli {
     #[arg(short, long, default_value = ".")]
     project_dir: String,
 
+    /// PostgreSQL connection string
+    #[arg(long, env = "CODESEARCH_PG_URL", default_value = DEFAULT_PG_URL)]
+    pg_url: String,
+
     /// Enable verbose logging
     #[arg(short, long)]
     verbose: bool,
@@ -43,7 +51,7 @@ struct Cli {
 
 #[derive(Subcommand)]
 enum Commands {
-    /// Initialize local RuVector in project
+    /// Initialize local CodeSearch in project
     Init {
         /// Force reinitialization
         #[arg(long)]
@@ -234,11 +242,11 @@ fn main() -> Result<()> {
         .canonicalize()
         .map_err(|e| anyhow!("Invalid project directory: {}", e))?;
 
-    info!("Local RuVector Accelerator v1.0.0");
+    info!("Local CodeSearch Accelerator v1.0.0");
     info!("Project: {}", project_path.display());
 
-    // Check if RuVector is initialized for most commands
-    let ruvector_dir = project_path.join(".ruvector");
+    // Check if CodeSearch is initialized for most commands
+    let ruvector_dir = project_path.join(".codesearch");
 
     match cli.command {
         Commands::Init { force } => {
@@ -247,14 +255,14 @@ fn main() -> Result<()> {
             cmd.execute()?;
         }
         Commands::Index { path, types, patterns, force } => {
-            // Auto-initialize RuVector if not already initialized
-            let db_path = local_ruvector::paths::get_database_path()?;
+            // Auto-initialize CodeSearch if not already initialized
+            let db_path = codesearch::paths::get_database_path()?;
             if !db_path.exists() {
-                info!("RuVector not initialized, auto-initializing...");
+                info!("CodeSearch not initialized, auto-initializing...");
                 let init_cmd = InitCommand::new(&project_path, false);
                 init_cmd.check_environment()?;
                 init_cmd.execute()?;
-                info!("✅ RuVector auto-initialized");
+                info!("✅ CodeSearch auto-initialized");
             }
 
             let file_types: Vec<String> = types.split(',').map(|s| s.trim().to_string()).collect();
@@ -267,6 +275,7 @@ fn main() -> Result<()> {
                 file_types,
                 pattern_list,
                 force,
+                Some(&cli.pg_url),
             )?;
             let stats = cmd.execute()?;
             println!("✅ Indexed {} files with {} patterns", stats.files_processed, stats.embeddings_generated);
@@ -281,10 +290,10 @@ fn main() -> Result<()> {
             batch,
             output,
         } => {
-            // Check centralized database exists (not local .ruvector dir)
+            // Check centralized database exists (not local .codesearch dir)
             let db_path = paths::get_database_path()?;
             if !db_path.exists() {
-                return Err(anyhow!("RuVector database not found. Run 'init' and 'index' first."));
+                return Err(anyhow!("CodeSearch database not found. Run 'init' and 'index' first."));
             }
 
             if let Some(batch_file) = batch {
@@ -310,6 +319,7 @@ fn main() -> Result<()> {
                     output_format,
                     context,
                     file,
+                    Some(&cli.pg_url),
                 )?;
                 cmd.execute()?;
             }
@@ -320,10 +330,10 @@ fn main() -> Result<()> {
             analyze,
             report,
         } => {
-            // Check centralized database exists (not local .ruvector dir)
+            // Check centralized database exists (not local .codesearch dir)
             let db_path = paths::get_database_path()?;
             if !db_path.exists() {
-                return Err(anyhow!("RuVector database not found. Run 'init' and 'index' first."));
+                return Err(anyhow!("CodeSearch database not found. Run 'init' and 'index' first."));
             }
 
             let output_format = match format {
@@ -347,10 +357,10 @@ fn main() -> Result<()> {
             dry_run,
             force,
         } => {
-            // Check centralized database exists (not local .ruvector dir)
+            // Check centralized database exists (not local .codesearch dir)
             let db_path = paths::get_database_path()?;
             if !db_path.exists() {
-                return Err(anyhow!("RuVector database not found. Run 'init' and 'index' first."));
+                return Err(anyhow!("CodeSearch database not found. Run 'init' and 'index' first."));
             }
 
             let cmd = CleanupCommand::new(
@@ -373,36 +383,36 @@ fn main() -> Result<()> {
             
             if ruvector_dir.exists() {
                 std::fs::remove_dir_all(&ruvector_dir)?;
-                println!("✅ Reset complete: removed .ruvector directory");
+                println!("✅ Reset complete: removed .codesearch directory");
             } else {
-                println!("ℹ️  No RuVector data found to reset");
+                println!("ℹ️  No CodeSearch data found to reset");
             }
         }
         Commands::Migrate { source: _, path: _, dry_run: _ } => {
             println!("⚠️  Migration feature not yet implemented");
         }
         Commands::Export { path, format: _, include_embeddings: _ } => {
-            // Check centralized database exists (not local .ruvector dir)
+            // Check centralized database exists (not local .codesearch dir)
             let db_path = paths::get_database_path()?;
             if !db_path.exists() {
-                return Err(anyhow!("RuVector database not found. Run 'init' and 'index' first."));
+                return Err(anyhow!("CodeSearch database not found. Run 'init' and 'index' first."));
             }
             println!("⚠️  Export feature not yet implemented");
             println!("Would export to: {}", path);
         }
         Commands::Find { args } => {
-            // Check centralized database exists (not local .ruvector dir)
+            // Check centralized database exists (not local .codesearch dir)
             let db_path = paths::get_database_path()?;
             if !db_path.exists() {
-                return Err(anyhow!("RuVector database not found. Run 'init' and 'index' first."));
+                return Err(anyhow!("CodeSearch database not found. Run 'init' and 'index' first."));
             }
             args.execute(&project_path)?;
         }
         Commands::Refs { args } => {
-            // Check centralized database exists (not local .ruvector dir)
+            // Check centralized database exists (not local .codesearch dir)
             let db_path = paths::get_database_path()?;
             if !db_path.exists() {
-                return Err(anyhow!("RuVector database not found. Run 'init' and 'index' first."));
+                return Err(anyhow!("CodeSearch database not found. Run 'init' and 'index' first."));
             }
             args.execute(&project_path)?;
         }

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

@@ -1,25 +1,25 @@
-// Centralized path management for RuVector index
+// Centralized path management for CodeSearch index
 use std::path::PathBuf;
 use anyhow::{Result, Context};
 
-/// Get the centralized RuVector directory
-/// Location: ~/.local/share/ruvector/
-pub fn get_ruvector_dir() -> Result<PathBuf> {
+/// Get the centralized CodeSearch directory
+/// Location: ~/.local/share/codesearch/
+pub fn get_codesearch_dir() -> Result<PathBuf> {
     let home = std::env::var("HOME")
         .context("HOME environment variable not set")?;
-    
-    let ruvector_dir = PathBuf::from(home)
+
+    let codesearch_dir = PathBuf::from(home)
         .join(".local")
         .join("share")
-        .join("ruvector");
-    
-    Ok(ruvector_dir)
+        .join("codesearch");
+
+    Ok(codesearch_dir)
 }
 
 /// Get the centralized database path
-/// Location: ~/.local/share/ruvector/index_v2.db
+/// Location: ~/.local/share/codesearch/index_v2.db
 pub fn get_database_path() -> Result<PathBuf> {
-    Ok(get_ruvector_dir()?.join("index_v2.db"))
+    Ok(get_codesearch_dir()?.join("index_v2.db"))
 }
 
 /// DEPRECATED: V1 index is no longer used
@@ -27,5 +27,11 @@ pub fn get_database_path() -> Result<PathBuf> {
 /// This function remains only for migration cleanup
 #[deprecated(since = "2.0.0", note = "V1 index removed. Use get_database_path() for V2.")]
 pub fn get_v1_index_dir() -> Result<PathBuf> {
-    Ok(get_ruvector_dir()?.join("index"))
-}
+    Ok(get_codesearch_dir()?.join("index"))
+}
+
+// Legacy alias for backwards compatibility during transition
+#[deprecated(since = "0.2.0", note = "Use get_codesearch_dir instead")]
+pub fn get_ruvector_dir() -> Result<PathBuf> {
+    get_codesearch_dir()
+}

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

@@ -51,7 +51,6 @@ impl QueryV2 {
         let project_root_str = project_root
             .to_string_lossy()
             .to_string();
-        let project_root_pattern = format!("{}%", project_root_str);
 
         // 2. Get all embeddings with entity details, filtered by project root
         let mut stmt = self.store.conn.prepare(
@@ -61,10 +60,10 @@ impl QueryV2 {
                     ee.embedding
              FROM entities e
              JOIN entity_embeddings ee ON e.id = ee.entity_id
-             WHERE e.file_path LIKE ?"
+             WHERE e.project_root = ?"
         )?;
-        
-        let embedding_rows = stmt.query_map(params![project_root_pattern], |row| {
+
+        let embedding_rows = stmt.query_map(params![project_root_str], |row| {
             let entity_id: i64 = row.get(0)?;
             let entity_kind: String = row.get(1)?;
             let entity_name: String = row.get(2)?;

package/.claude/skills/cfn-codesearch/src/store_pgvector.rs

@@ -0,0 +1,301 @@
+//! PostgreSQL/pgvector storage backend for CodeSearch
+//!
+//! This module provides vector similarity search using pgvector extension.
+//! Embeddings are stored in pgvector for fast HNSW-indexed similarity search.
+
+use anyhow::{Result, Context, anyhow};
+use tokio_postgres::NoTls;
+use deadpool_postgres::{Config, Pool, Runtime};
+use serde::{Serialize, Deserialize};
+use tracing::{info, debug, warn};
+use pgvector::Vector;
+
+use crate::store_v2::Entity;
+
+/// Expected embedding dimension for text-embedding-3-small model
+pub const EMBEDDING_DIMENSION: usize = 1536;
+
+/// PostgreSQL connection pool for pgvector operations
+pub struct PgvectorStore {
+    pool: Pool,
+}
+
+impl PgvectorStore {
+    /// Create a new pgvector store from connection URL
+    pub async fn new(database_url: &str) -> Result<Self> {
+        let config = database_url.parse::<tokio_postgres::Config>()
+            .context("Invalid PostgreSQL connection string")?;
+
+        let mut pool_config = Config::new();
+        pool_config.host = config.get_hosts().first()
+            .and_then(|h| match h {
+                tokio_postgres::config::Host::Tcp(s) => Some(s.clone()),
+                _ => None,
+            });
+        pool_config.port = config.get_ports().first().copied();
+        pool_config.user = config.get_user().map(|s| s.to_string());
+        pool_config.password = config.get_password().map(|p| String::from_utf8_lossy(p).to_string());
+        pool_config.dbname = config.get_dbname().map(|s| s.to_string());
+
+        // Configure connection pool for better resource management
+        // Limit max connections to avoid pool exhaustion
+        pool_config.manager = Some(deadpool_postgres::ManagerConfig {
+            recycling_method: deadpool_postgres::RecyclingMethod::Fast,
+        });
+        // Set max_size through pool_config fields directly
+        pool_config.pool = Some(deadpool_postgres::PoolConfig::new(10));
+
+        let pool = pool_config.create_pool(Some(Runtime::Tokio1), NoTls)
+            .context("Failed to create connection pool")?;
+
+        // Verify connection and pgvector extension
+        let client = pool.get().await.context("Failed to get connection from pool")?;
+        client.execute("SELECT 1", &[]).await.context("Failed to ping database")?;
+
+        // Check pgvector extension
+        let row = client.query_opt(
+            "SELECT extversion FROM pg_extension WHERE extname = 'vector'",
+            &[]
+        ).await.context("Failed to check pgvector extension")?;
+
+        if row.is_none() {
+            return Err(anyhow!("pgvector extension not installed. Run: CREATE EXTENSION vector;"));
+        }
+
+        let version: String = row.unwrap().get(0);
+        info!("Connected to PostgreSQL with pgvector v{}", version);
+        Ok(Self { pool })
+    }
+
+    /// Store an entity with its embedding
+    pub async fn store_entity_with_embedding(
+        &self,
+        entity: &Entity,
+        embedding: &[f32],
+        project_root: &str,
+    ) -> Result<i64> {
+        // Validate embedding dimension
+        if embedding.len() != EMBEDDING_DIMENSION {
+            return Err(anyhow!(
+                "Invalid embedding dimension: expected {}, got {} for entity '{}'",
+                EMBEDDING_DIMENSION, embedding.len(), entity.name
+            ));
+        }
+
+        let client = self.pool.get().await
+            .context(format!("Failed to get connection from pool for entity: {}", entity.name))?;
+
+        // Convert embedding to pgvector Vector type
+        let embedding_vec = Vector::from(embedding.to_vec());
+
+        let row = client.query_one(
+            r#"
+            INSERT INTO codesearch.embeddings (
+                entity_kind, entity_name, file_path, line_number,
+                signature, doc_comment, project_root, embedding
+            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+            ON CONFLICT (project_root, file_path, entity_name, entity_kind, line_number)
+            DO UPDATE SET
+                signature = EXCLUDED.signature,
+                doc_comment = EXCLUDED.doc_comment,
+                embedding = EXCLUDED.embedding,
+                updated_at = NOW()
+            RETURNING id
+            "#,
+            &[
+                &format!("{:?}", entity.kind),
+                &entity.name,
+                &entity.file_path,
+                &(entity.line_number as i32),
+                &entity.signature,
+                &entity.doc_comment,
+                &project_root,
+                &embedding_vec,
+            ]
+        ).await.context(format!(
+            "Failed to store entity '{}' at {}:{}",
+            entity.name, entity.file_path, entity.line_number
+        ))?;
+
+        Ok(row.get::<_, i64>(0))
+    }
+
+    /// Search for similar entities by embedding
+    pub async fn search_similar(
+        &self,
+        query_embedding: &[f32],
+        max_results: usize,
+        threshold: f32,
+        project_root: Option<&str>,
+    ) -> Result<Vec<SearchResult>> {
+        // Validate query embedding dimension
+        if query_embedding.len() != EMBEDDING_DIMENSION {
+            return Err(anyhow!(
+                "Invalid query embedding dimension: expected {}, got {}",
+                EMBEDDING_DIMENSION, query_embedding.len()
+            ));
+        }
+
+        let client = self.pool.get().await.context("Failed to get connection")?;
+
+        // Convert query embedding to pgvector Vector type
+        let embedding_vec = Vector::from(query_embedding.to_vec());
+
+        debug!("Searching pgvector with threshold {} for {} results", threshold, max_results);
+
+        // Convert threshold to f64 for PostgreSQL float8 compatibility
+        let threshold_f64 = threshold as f64;
+
+        let rows = if let Some(project) = project_root {
+            client.query(
+                r#"
+                SELECT id, entity_kind, entity_name, file_path, line_number,
+                       signature, doc_comment, project_root,
+                       1 - (embedding <=> $1) as similarity
+                FROM codesearch.embeddings
+                WHERE project_root = $2
+                  AND 1 - (embedding <=> $1) >= $3
+                ORDER BY embedding <=> $1
+                LIMIT $4
+                "#,
+                &[
+                    &embedding_vec,
+                    &project,
+                    &threshold_f64,
+                    &(max_results as i64),
+                ]
+            ).await
+        } else {
+            client.query(
+                r#"
+                SELECT id, entity_kind, entity_name, file_path, line_number,
+                       signature, doc_comment, project_root,
+                       1 - (embedding <=> $1) as similarity
+                FROM codesearch.embeddings
+                WHERE 1 - (embedding <=> $1) >= $2
+                ORDER BY embedding <=> $1
+                LIMIT $3
+                "#,
+                &[
+                    &embedding_vec,
+                    &threshold_f64,
+                    &(max_results as i64),
+                ]
+            ).await
+        }.context("Failed to search embeddings")?;
+
+        let results = rows.iter().map(|row| {
+            SearchResult {
+                id: row.get::<_, i64>("id"),
+                entity_kind: row.get::<_, String>("entity_kind"),
+                entity_name: row.get::<_, String>("entity_name"),
+                file_path: row.get::<_, String>("file_path"),
+                line_number: row.get::<_, i32>("line_number") as i64,
+                signature: row.get::<_, Option<String>>("signature"),
+                doc_comment: row.get::<_, Option<String>>("doc_comment"),
+                project_root: row.get::<_, String>("project_root"),
+                similarity: row.get::<_, f64>("similarity") as f32,
+            }
+        }).collect();
+
+        Ok(results)
+    }
+
+    /// Get entity count by project
+    pub async fn get_entity_count(&self, project_root: Option<&str>) -> Result<i64> {
+        let client = self.pool.get().await.context("Failed to get connection")?;
+
+        let count: i64 = if let Some(project) = project_root {
+            let row = client.query_one(
+                "SELECT COUNT(*) FROM codesearch.embeddings WHERE project_root = $1",
+                &[&project]
+            ).await?;
+            row.get(0)
+        } else {
+            let row = client.query_one(
+                "SELECT COUNT(*) FROM codesearch.embeddings",
+                &[]
+            ).await?;
+            row.get(0)
+        };
+
+        Ok(count)
+    }
+
+    /// Delete entities for a file (for re-indexing)
+    pub async fn delete_file_entities(&self, file_path: &str, project_root: &str) -> Result<u64> {
+        let client = self.pool.get().await.context("Failed to get connection")?;
+
+        let result = client.execute(
+            "DELETE FROM codesearch.embeddings WHERE file_path = $1 AND project_root = $2",
+            &[&file_path, &project_root]
+        ).await.context("Failed to delete file entities")?;
+
+        Ok(result)
+    }
+}
+
+/// Search result from pgvector similarity search
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SearchResult {
+    pub id: i64,
+    pub entity_kind: String,
+    pub entity_name: String,
+    pub file_path: String,
+    pub line_number: i64,
+    pub signature: Option<String>,
+    pub doc_comment: Option<String>,
+    pub project_root: String,
+    pub similarity: f32,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_embedding_dimension_constant() {
+        // Verify the constant matches the expected dimension for text-embedding-3-small
+        assert_eq!(EMBEDDING_DIMENSION, 1536);
+    }
+
+    #[test]
+    fn test_valid_embedding_dimension() {
+        let valid_embedding = vec![0.1f32; 1536];
+        assert_eq!(valid_embedding.len(), EMBEDDING_DIMENSION);
+    }
+
+    #[test]
+    fn test_invalid_embedding_dimension_too_small() {
+        let invalid_embedding = vec![0.1f32; 512];
+        assert_ne!(invalid_embedding.len(), EMBEDDING_DIMENSION);
+        assert!(invalid_embedding.len() < EMBEDDING_DIMENSION);
+    }
+
+    #[test]
+    fn test_invalid_embedding_dimension_too_large() {
+        let invalid_embedding = vec![0.1f32; 3072];
+        assert_ne!(invalid_embedding.len(), EMBEDDING_DIMENSION);
+        assert!(invalid_embedding.len() > EMBEDDING_DIMENSION);
+    }
+
+    #[tokio::test]
+    #[ignore = "Requires PostgreSQL with pgvector"]
+    async fn test_pgvector_connection() {
+        // This test requires CODESEARCH_PG_URL to be set
+        if let Ok(pg_url) = std::env::var("CODESEARCH_PG_URL") {
+            let store = PgvectorStore::new(&pg_url).await;
+            assert!(store.is_ok(), "Should connect to pgvector: {:?}", store.err());
+        }
+    }
+
+    #[tokio::test]
+    #[ignore = "Requires PostgreSQL with pgvector"]
+    async fn test_entity_count() {
+        if let Ok(pg_url) = std::env::var("CODESEARCH_PG_URL") {
+            let store = PgvectorStore::new(&pg_url).await.unwrap();
+            let count = store.get_entity_count(None).await;
+            assert!(count.is_ok(), "Should get entity count: {:?}", count.err());
+        }
+    }
+}

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

@@ -9,6 +9,9 @@ use crate::schema_v2::{EntityKind, RefKind, Visibility};
 use crate::search_engine::SearchResult;
 use crate::path_validator;
 
+/// Expected embedding dimension for text-embedding-3-small model
+const EMBEDDING_DIMENSION: usize = 1536;
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Entity {
     pub id: i64,
@@ -385,7 +388,15 @@ impl StoreV2 {
     // Embedding operations
     pub fn store_embedding(&self, entity_id: i64, embedding: &[f32], model: &str) -> Result<()> {
         debug!("Storing embedding for entity: {}", entity_id);
-        
+
+        // Validate embedding dimension
+        if embedding.len() != EMBEDDING_DIMENSION {
+            return Err(anyhow!(
+                "Invalid embedding dimension: expected {}, got {} for entity_id {}",
+                EMBEDDING_DIMENSION, embedding.len(), entity_id
+            ));
+        }
+
         // Serialize embedding to bytes
         let embedding_bytes: Vec<u8> = embedding
             .iter()

package/.claude/skills/{cfn-local-ruvector-accelerator → cfn-codesearch}/test-agent-lifecycle-integration.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-# test-agent-lifecycle-integration.sh - Test RuVector agent lifecycle integration
+# test-agent-lifecycle-integration.sh - Test CodeSearch agent lifecycle integration
 #
 # Purpose: Verify that transcript ingestion and failure analysis work correctly
 
@@ -17,7 +17,7 @@ GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 NC='\033[0m' # No Color
 
-echo "=== RuVector Agent Lifecycle Integration Test ==="
+echo "=== CodeSearch Agent Lifecycle Integration Test ==="
 echo ""
 
 # ============================================================================
@@ -195,17 +195,17 @@ echo ""
 
 echo "Test 5: Verifying metadata updates..."
 
-# Check if agent metadata was updated with RuVector processing flag
+# Check if agent metadata was updated with CodeSearch processing flag
 METADATA=$(sqlite3 "$DB_PATH" "SELECT metadata FROM agents WHERE id = '$TEST_AGENT_ID';")
 
-if echo "$METADATA" | grep -q "ruvector_processed"; then
+if echo "$METADATA" | grep -q "codesearch_processed"; then
     echo -e "${GREEN}✓${NC} Agent metadata updated with processing flag"
 else
     echo -e "${YELLOW}⚠${NC} Agent metadata not updated"
 fi
 
-if echo "$METADATA" | grep -q "ruvector_snippets"; then
-    SNIPPET_COUNT_META=$(echo "$METADATA" | grep -o '"ruvector_snippets":[0-9]*' | cut -d':' -f2)
+if echo "$METADATA" | grep -q "codesearch_snippets"; then
+    SNIPPET_COUNT_META=$(echo "$METADATA" | grep -o '"codesearch_snippets":[0-9]*' | cut -d':' -f2)
     echo -e "${GREEN}✓${NC} Snippet count recorded in metadata: $SNIPPET_COUNT_META"
 else
     echo -e "${YELLOW}⚠${NC} Snippet count not recorded"

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

@@ -1,13 +1,13 @@
 #!/bin/bash
-# test-local-ruvector.sh - Test Local RuVector implementation
+# test-local-codesearch.sh - Test Local CodeSearch implementation
 
 set -e
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-STORAGE_PATH="${HOME}/.local-ruvector-test"
-TEST_DIR="/tmp/ruvector-test-project"
+STORAGE_PATH="${HOME}/.local-codesearch-test"
+TEST_DIR="/tmp/codesearch-test-project"
 
-echo "🧪 Testing Local RuVector Accelerator..."
+echo "🧪 Testing Local CodeSearch Accelerator..."
 
 # Clean up previous test
 rm -rf "$STORAGE_PATH" "$TEST_DIR"
@@ -168,10 +168,10 @@ EOF
 
 echo "✅ Test files created"
 
-# Initialize Local RuVector
+# Initialize Local CodeSearch
 echo ""
-echo "🚀 Initializing Local RuVector..."
-STORAGE_PATH="$STORAGE_PATH" "$SCRIPT_DIR/init-local-ruvector.sh"
+echo "🚀 Initializing Local CodeSearch..."
+STORAGE_PATH="$STORAGE_PATH" "$SCRIPT_DIR/init-local-codesearch.sh"
 
 # Index test files
 echo ""

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

@@ -9,7 +9,7 @@ echo "=== Testing Phase 4 Query API Implementation ==="
 echo
 
 # Check if the binary was built
-BINARY_PATH="./target/debug/local-ruvector"
+BINARY_PATH="./target/debug/local-codesearch"
 if [ ! -f "$BINARY_PATH" ]; then
     echo "❌ Binary not found at $BINARY_PATH"
     echo "Please build the project first with: cargo build"
@@ -57,7 +57,7 @@ echo "✅ Created test_code/sample.rs"
 echo
 
 # Test 3: Initialize and index
-echo "4. Initializing ruvector..."
+echo "4. Initializing codesearch..."
 $BINARY_PATH init --force
 echo