claude-flow-novice 2.18.15 → 2.18.17

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

@@ -1,8 +1,91 @@
-# 1. Initialize local RuVector
-./target/release/local-ruvector init
+# RuVector Local Semantic Code Search
 
-# 2. Index your codebase
-./target/release/local-ruvector index --path /path/to/project --types rs
+## WHEN TO USE THIS SKILL
 
-# 3. Query patterns instantly
-./target/release/local-ruvector query --pattern "authentication rust" --limit 5
+**USE RuVector V2 SQL for ALL indexed projects (400x FASTER than grep):**
+```bash
+# Exact name lookup - 0.002s vs grep's 0.8s
+sqlite3 ~/.local/share/ruvector/index_v2.db "SELECT file_path, line_number FROM entities WHERE name = 'MyFunction';"
+
+# Fuzzy search - 0.004s
+sqlite3 ~/.local/share/ruvector/index_v2.db "SELECT file_path, line_number FROM entities WHERE name LIKE '%Store%' LIMIT 10;"
+```
+
+**USE grep/rg ONLY when:**
+- Project is NOT indexed yet
+- Searching for strings that aren't code entities (error messages, comments, config values)
+- Quick one-off search in small directory
+
+**USE RuVector semantic search when:**
+- "Where is authentication implemented?" (conceptual search)
+- Finding similar patterns you can't name exactly
+- Discovering how a feature is built
+
+## Quick Commands
+
+### Semantic Search (V1 - Embeddings)
+```bash
+# Natural language search
+/codebase-search "authentication middleware pattern"
+/cfn-ruvector-search "error handling in API routes"
+
+# CLI direct
+./.claude/skills/cfn-local-ruvector-accelerator/target/release/local-ruvector query --pattern "user login flow"
+```
+
+### Structural Search (V2 - SQL on AST)
+```bash
+# Find all callers of a function
+sqlite3 ~/.local/share/ruvector/index_v2.db \
+  "SELECT * FROM refs WHERE target_name = 'MyFunction';"
+
+# Find all functions in a file
+sqlite3 ~/.local/share/ruvector/index_v2.db \
+  "SELECT name, line_number FROM entities WHERE file_path LIKE '%myfile.rs' AND kind = 'function';"
+
+# Find entities by project (multi-project isolation)
+sqlite3 ~/.local/share/ruvector/index_v2.db \
+  "SELECT COUNT(*) FROM entities WHERE project_root = '/path/to/project';"
+```
+
+## Index Management
+
+```bash
+# Index a project (first time or full rebuild)
+./target/release/local-ruvector index --path /path/to/project --types rs,ts,py
+
+# Incremental update (after code changes)
+/codebase-reindex
+
+# Check index stats
+sqlite3 ~/.local/share/ruvector/index_v2.db "SELECT project_root, COUNT(*) FROM entities GROUP BY project_root;"
+```
+
+## Key Features
+
+- **Multi-project isolation**: Index multiple projects in single database without data collision
+- **Non-destructive**: Indexing one project never deletes data from other projects
+- **Centralized storage**: `~/.local/share/ruvector/index_v2.db`
+- **Dual search**: V1 semantic (embeddings) + V2 structural (SQL on AST)
+- **Fast**: Rust binary with SQLite backend
+
+## Database Location
+```
+~/.local/share/ruvector/index_v2.db
+```
+
+## For Agents
+
+Before implementing changes, ALWAYS query RuVector first:
+```bash
+# Find similar patterns
+/codebase-search "relevant search terms" --top 5
+
+# Query past errors
+./.claude/skills/cfn-ruvector-codebase-index/query-error-patterns.sh --task-description "description"
+
+# Query learnings
+./.claude/skills/cfn-ruvector-codebase-index/query-learnings.sh --task-description "description" --category PATTERN
+```
+
+This prevents duplicated work and leverages existing solutions.

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

@@ -1,3 +1,47 @@
+//! # RuVector Index Command
+//!
+//! ## IMPORTANT: Run from PROJECT ROOT
+//!
+//! This indexer MUST be run from the project root directory to index all files correctly.
+//! Running from a subdirectory will only index that subdirectory.
+//!
+//! ## Recommended Usage:
+//! ```bash
+//! cd /path/to/project-root
+//! local-ruvector index --path . --types rs,ts,js,json,md,sh --force
+//! ```
+//!
+//! ## Supported File Types (default):
+//! - rs, ts, js, json, md, sh, yaml, yml, txt, config
+//! - Use --types to specify custom extensions
+//!
+//! ## Excluded Directories (see EXCLUDED_DIRS constant - 52 patterns):
+//! - Dependencies: node_modules, vendor, .pnpm, .yarn
+//! - Build artifacts: target, dist, build, out, .next, .nuxt, .output, .turbo, .parcel-cache
+//! - VCS: .git, .svn, .hg
+//! - IDE: .idea, .vscode, .vs
+//! - 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
+//! - Backups/temp: backups, .backups, backup, tmp, .tmp, temp, logs
+//! - Test artifacts: __snapshots__, __mocks__, playwright-report, test-results
+//! - Doc builds: _site, .docusaurus, site
+//! - NOTE: .claude directory IS included (contains important config)
+//!
+//! ## Excluded Files (see EXCLUDED_FILES constant - 41 patterns):
+//! - Secrets: .env*, credentials.json, secrets.json, .npmrc, .pypirc, .netrc, id_rsa, *.pem, *.key
+//! - Lock files: package-lock.json, yarn.lock, pnpm-lock.yaml, Cargo.lock, go.sum, etc.
+//! - Backups: *.bak, *.backup, *.orig, *.swp, *~
+//! - Minified/generated: *.min.js, *.min.css, *.bundle.js, *.chunk.js, *.js.map, *.d.ts
+//! - Binary/data: *.wasm, *.db, *.sqlite
+//! - Build info: *.snap, *.eslintcache, *.tsbuildinfo
+//!
+//! ## Multi-Project Isolation:
+//! - Each project root is isolated via project_root column in v2 schema
+//! - Centralized database at ~/.local/share/ruvector/index_v2.db
+//! - Queries are scoped to the project root passed during indexing
+
 use anyhow::{Result, Context, anyhow};
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -21,6 +65,152 @@ use crate::schema_v2::{EntityKind, RefKind, Visibility};
 use crate::path_validator;
 use local_ruvector::paths::{get_ruvector_dir, get_database_path, get_v1_index_dir};
 
+/// Directories to exclude from indexing.
+/// These are typically build artifacts, dependencies, VCS, or sensitive directories.
+const EXCLUDED_DIRS: &[&str] = &[
+    // Package managers & dependencies
+    "node_modules",      // npm/yarn/pnpm dependencies
+    "vendor",            // Go/PHP vendor dependencies
+    ".pnpm",             // pnpm store
+    ".yarn",             // Yarn 2+ PnP cache
+
+    // Build artifacts
+    "target",            // Rust/Maven build artifacts
+    "dist",              // JS/TS build output
+    "build",             // Generic build output
+    "out",               // Common output directory
+    ".next",             // Next.js build
+    ".nuxt",             // Nuxt.js build
+    ".output",           // Nitro/Nuxt output
+    ".turbo",            // Turborepo cache
+    ".parcel-cache",     // Parcel bundler cache
+    ".webpack",          // Webpack cache
+
+    // Version control
+    ".git",              // Git repository data
+    ".svn",              // Subversion
+    ".hg",               // Mercurial
+
+    // IDE & editor
+    ".idea",             // JetBrains IDEs
+    ".vscode",           // VS Code (may contain sensitive settings)
+    ".vs",               // Visual Studio
+
+    // Cache & temp
+    ".cache",            // Generic cache directories
+    "__pycache__",       // Python bytecode cache
+    ".pytest_cache",     // Pytest cache
+    ".mypy_cache",       // Mypy cache
+    ".ruff_cache",       // Ruff linter cache
+    "coverage",          // Test coverage reports
+    ".nyc_output",       // NYC coverage output
+    ".eslintcache",      // ESLint cache (dir form)
+
+    // Virtual environments
+    ".venv",             // Python virtual environments
+    "venv",              // Python venv (alternate)
+    ".env",              // dotenv directories (not files)
+    "env",               // Generic env directory
+
+    // Infrastructure as Code
+    ".terraform",        // Terraform state/cache
+    ".serverless",       // Serverless framework
+    ".aws-sam",          // AWS SAM
+
+    // Project-specific
+    ".artifacts",        // CFN Loop artifacts
+    ".ruvector",         // RuVector local index (avoid self-indexing)
+    ".archive",          // Archived/deprecated code
+    "archive",           // Archive directories
+
+    // Backups & generated
+    "backups",           // Backup directories
+    ".backups",          // Hidden backup directories
+    "backup",            // Singular backup directory
+    ".backup",           // Hidden singular backup
+    "tmp",               // Temporary files
+    ".tmp",              // Hidden temp files
+    "temp",              // Temp directory
+    "logs",              // Log directories
+    ".logs",             // Hidden logs
+
+    // Test artifacts (not source code)
+    "__snapshots__",     // Jest snapshots
+    "__mocks__",         // Jest mocks (usually generated)
+    ".storybook",        // Storybook config (not source)
+    "storybook-static",  // Storybook build output
+    "playwright-report", // Playwright test reports
+    "test-results",      // Generic test results
+
+    // Documentation builds
+    "_site",             // Jekyll output
+    ".docusaurus",       // Docusaurus cache
+    "site",              // MkDocs output
+];
+
+/// File patterns to exclude from indexing.
+/// These are sensitive files or files that shouldn't be semantically indexed.
+const EXCLUDED_FILES: &[&str] = &[
+    // Sensitive/secrets
+    ".env",              // Environment variables (secrets!)
+    ".env.local",        // Local env overrides
+    ".env.development",  // Dev env
+    ".env.production",   // Prod env
+    ".env.test",         // Test env
+    ".env.example",      // Example env (may contain structure hints)
+    "credentials.json",  // GCP/generic credentials
+    "secrets.json",      // Generic secrets
+    "secrets.yaml",      // Kubernetes secrets
+    "service-account.json", // GCP service account
+    ".npmrc",            // npm auth tokens
+    ".pypirc",           // PyPI auth
+    ".netrc",            // Network credentials
+    "id_rsa",            // SSH private key
+    "id_ed25519",        // SSH private key
+    ".pem",              // Certificate/key files
+    ".key",              // Key files
+
+    // Lock files (large, not useful for semantic search)
+    "package-lock.json", // npm lock
+    "yarn.lock",         // Yarn lock
+    "pnpm-lock.yaml",    // pnpm lock
+    "Cargo.lock",        // Rust lock
+    "poetry.lock",       // Python poetry lock
+    "Gemfile.lock",      // Ruby bundler lock
+    "composer.lock",     // PHP composer lock
+    "go.sum",            // Go module checksums
+    "flake.lock",        // Nix flake lock
+
+    // Backups
+    ".bak",              // Generic backup extension
+    ".backup",           // Backup files
+    ".orig",             // Original files (merge conflicts)
+    ".swp",              // Vim swap files
+    ".swo",              // Vim swap files
+    "~",                 // Emacs backup files
+
+    // Generated/minified (not useful for semantic search)
+    ".min.js",           // Minified JS
+    ".min.css",          // Minified CSS
+    ".bundle.js",        // Bundled JS
+    ".chunk.js",         // Webpack chunks
+    ".js.map",           // JavaScript source maps
+    ".css.map",          // CSS source maps
+    ".d.ts",             // TypeScript declarations (generated, verbose)
+    ".d.ts.map",         // TypeScript declaration maps
+
+    // Binary/data files (can't extract meaningful entities)
+    ".wasm",             // WebAssembly binary
+    ".db",               // SQLite/database files
+    ".sqlite",           // SQLite files
+    ".sqlite3",          // SQLite3 files
+
+    // Large generated files
+    ".snap",             // Jest snapshots
+    ".eslintcache",      // ESLint cache file
+    ".tsbuildinfo",      // TypeScript incremental build info
+];
+
 #[derive(Debug)]
 pub struct IndexStats {
     pub files_processed: usize,
@@ -148,21 +338,19 @@ impl IndexCommand {
 
     fn collect_files(&self) -> Result<Vec<PathBuf>> {
         info!("Collecting files to index from: {}", self.source_path.display());
+        info!("Excluded directories: {} patterns", EXCLUDED_DIRS.len());
+        info!("Excluded files: {} patterns", EXCLUDED_FILES.len());
 
         let mut files = Vec::new();
 
         let walker = WalkDir::new(&self.source_path)
             .into_iter()
             .filter_entry(|e| {
-                let path = e.path();
                 let name = e.file_name().to_string_lossy();
 
-                // Exclude build artifacts, dependencies, and temporary files
-                // Allow .claude and other important hidden folders
-                match name.as_ref() {
-                    "node_modules" | "target" | "dist" | "build" | ".git" | ".artifacts" => false,
-                    _ => true
-                }
+                // Exclude build artifacts, dependencies, and sensitive directories
+                // Allow .claude and other important folders (not in EXCLUDED_DIRS)
+                !EXCLUDED_DIRS.contains(&name.as_ref())
             })
             .filter_map(|e| e.ok())
             .filter(|e| {
@@ -174,8 +362,25 @@ impl IndexCommand {
                     return false;
                 }
 
-                // Index ALL files regardless of extension
-                // File type metadata is captured during processing
+                let file_name = e.file_name().to_string_lossy();
+
+                // Exclude sensitive files by exact name match
+                if EXCLUDED_FILES.contains(&file_name.as_ref()) {
+                    return false;
+                }
+
+                // Exclude files by suffix pattern (e.g., ".min.js", ".bak")
+                for pattern in EXCLUDED_FILES {
+                    if pattern.starts_with('.') && file_name.ends_with(pattern) {
+                        return false;
+                    }
+                }
+
+                // Exclude emacs backup files ending with ~
+                if file_name.ends_with('~') {
+                    return false;
+                }
+
                 true
             });
 
@@ -187,17 +392,6 @@ impl IndexCommand {
         Ok(files)
     }
 
-    fn is_hidden(entry: &DirEntry) -> bool {
-        entry.file_name()
-            .to_str()
-            .map(|s| {
-                if s == ".claude" {
-                    return false;
-                }
-                s.starts_with('.')
-            })
-            .unwrap_or(false)
-    }
 
     fn process_files(&mut self, files: Vec<PathBuf>) -> Result<IndexStats> {
         let stats = Arc::new(RwLock::new(IndexStats::default()));
@@ -238,14 +432,21 @@ impl IndexCommand {
     ) -> Result<()> {
         let file_hash = self.calculate_file_hash(file_path)?;
 
+        // Check if file is already indexed with same hash (incremental indexing)
         if !self.force && self.is_file_indexed(file_path, &file_hash)? {
-            debug!("Skipping already indexed file: {}", file_path.display());
+            debug!("Skipping already indexed file (unchanged): {}", file_path.display());
             return Ok(());
         }
 
-        // Clean up old entries before reindexing to prevent duplicate entities
+        // Non-destructive update: Only delete entities for THIS specific file
+        // The delete_file_entities already scopes to project_root for multi-project safety
         let file_path_str = file_path.to_string_lossy();
-        self.store_v2.delete_file_entities(&file_path_str, &self.project_dir)?;
+
+        // Only clean up if the file was previously indexed (avoid unnecessary DB operations)
+        if self.is_file_in_index(file_path)? {
+            debug!("Updating existing file entries: {}", file_path.display());
+            self.store_v2.delete_file_entities(&file_path_str, &self.project_dir)?;
+        }
 
         let content = fs::read_to_string(file_path)
             .with_context(|| format!("Failed to read file: {}", file_path.display()))?;
@@ -276,7 +477,7 @@ impl IndexCommand {
             s.embeddings_generated += embeddings.len();
         }
 
-        self.mark_file_indexed(file_path, &file_hash)?;
+        self.mark_file_indexed(file_path, &file_hash, extraction_result.entities.len())?;
 
         Ok(())
     }
@@ -345,6 +546,7 @@ impl IndexCommand {
                 doc_comment: None,
                 attributes: None,
                 metadata: Some(serde_json::to_string(&entity.metadata)?),
+                project_root: project_root_str.to_string(),
                 created_at: chrono::Utc::now(),
                 updated_at: chrono::Utc::now(),
             };
@@ -460,15 +662,33 @@ impl IndexCommand {
         Ok(count > 0)
     }
 
-    fn mark_file_indexed(&self, file_path: &Path, file_hash: &str) -> Result<()> {
+    /// Check if file exists in the index (regardless of hash)
+    fn is_file_in_index(&self, file_path: &Path) -> Result<bool> {
+        let query = "SELECT COUNT(*) FROM file_hashes WHERE file_path = ?";
+        let mut stmt = self.store_v2.conn.prepare(query)?;
+        let count: i64 = stmt.query_row(
+            params![file_path.to_string_lossy()],
+            |row| row.get(0)
+        )?;
+        Ok(count > 0)
+    }
+
+    fn mark_file_indexed(&self, file_path: &Path, file_hash: &str, patterns_count: usize) -> Result<()> {
+        let timestamp = chrono::Utc::now().timestamp();
+        let file_path_str = file_path.to_string_lossy().to_string();
+
+        // Update file_hashes table (for incremental indexing)
         self.store_v2.conn.execute(
             "INSERT OR REPLACE INTO file_hashes (file_path, file_hash, indexed_at) VALUES (?1, ?2, ?3)",
-            params![
-                file_path.to_string_lossy(),
-                file_hash,
-                chrono::Utc::now().timestamp()
-            ]
+            params![&file_path_str, file_hash, timestamp]
         )?;
+
+        // Also update the files table (for legacy compatibility and stats)
+        self.store_v2.conn.execute(
+            "INSERT OR REPLACE INTO files (path, hash, last_indexed, patterns_count) VALUES (?1, ?2, ?3, ?4)",
+            params![&file_path_str, file_hash, timestamp, patterns_count as i64]
+        )?;
+
         Ok(())
     }
 

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

@@ -299,6 +299,7 @@ impl AstIndexCommand {
             let mut entity_map = HashMap::new();
             let mut type_usages = Vec::new();
 
+            let project_root_str = self.project_dir.to_string_lossy().to_string();
             for (idx, entity) in extraction_result.entities.iter().enumerate() {
                 let store_entity = StoreEntity {
                     id: 0,
@@ -313,6 +314,7 @@ impl AstIndexCommand {
                     doc_comment: None, // TODO: Extract doc comments
                     attributes: None, // TODO: Extract attributes
                     metadata: Some(serde_json::to_string(&entity.metadata)?),
+                    project_root: project_root_str.clone(),
                     created_at: chrono::Utc::now(),
                     updated_at: chrono::Utc::now(),
                 };
@@ -613,6 +615,7 @@ impl AstIndexCommand {
             Ok(entity.id)
         } else {
             // Create a placeholder entity for unknown references
+            let project_root_str = self.project_dir.to_string_lossy().to_string();
             let placeholder = StoreEntity {
                 id: 0,
                 kind: EntityKind::Function,
@@ -626,11 +629,11 @@ impl AstIndexCommand {
                 doc_comment: None,
                 attributes: None,
                 metadata: None,
+                project_root: project_root_str.clone(),
                 created_at: chrono::Utc::now(),
                 updated_at: chrono::Utc::now(),
             };
 
-            let project_root_str = self.project_dir.to_string_lossy();
             Ok(self.store_v2.insert_entity(&placeholder, &project_root_str)?)
         }
     }

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

@@ -4,8 +4,8 @@ use std::collections::HashMap;
 use tracing::info;
 use serde::{Serialize, Deserialize};
 
-use crate::search_engine::SearchEngine;
-use crate::sqlite_store::SqliteStore;
+use crate::store_v2::StoreV2;
+use crate::paths::get_database_path;
 
 #[derive(Debug, Clone)]
 pub enum OutputFormat {
@@ -42,26 +42,26 @@ impl StatsCommand {
     pub fn execute(&self) -> Result<()> {
         info!("Gathering statistics");
 
-        let search_engine = SearchEngine::new(Path::new(&self.project_dir))?;
-        let store = SqliteStore::new(&Path::new(&self.project_dir).join(".ruvector/index.db"))?;
+        // Use centralized v2 database
+        let db_path = get_database_path()?;
+        let store = StoreV2::new(&db_path)
+            .context("Failed to open centralized database")?;
 
-        // Load search engine
-        let mut engine = search_engine;
-        engine.load_or_create()?;
-
-        // Get stats from search engine
-        let index_stats = engine.get_stats();
-
-        // Get stats from database
+        // Get stats from v2 database
         let db_stats = store.get_stats()?;
 
-        // Create report
+        // Get database file size
+        let database_size_bytes = std::fs::metadata(&db_path)
+            .map(|m| m.len())
+            .unwrap_or(0);
+
+        // Create report using v2 stats
         let report = StatsReport {
-            total_files: db_stats.num_files,
-            total_embeddings: db_stats.num_embeddings,
-            total_patterns: index_stats.metadata_count,
-            index_size_bytes: index_stats.index_size_bytes,
-            database_size_bytes: db_stats.database_size_bytes,
+            total_files: db_stats.files_count,
+            total_embeddings: db_stats.embeddings_count,
+            total_patterns: db_stats.entities_count, // entities are our "patterns" in v2
+            index_size_bytes: 0, // v2 doesn't have separate index file
+            database_size_bytes,
             file_types: HashMap::new(), // TODO: Calculate actual file types
         };
 

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

@@ -28,7 +28,7 @@ pub fn create_text_fallback_extractor() -> Result<text_fallback::TextFallbackExt
 }
 
 /// Common entity kinds across languages
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum EntityKind {
     // Functions
     Function,

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

@@ -359,21 +359,21 @@ mod tests {
 
         SchemaV2::initialize(&conn)?;
 
-        // Insert test entities with different path patterns
+        // Insert test entities with project_root set (schema now requires it)
         conn.execute(
-            "INSERT INTO entities (kind, name, file_path, line_number) VALUES (?, ?, ?, ?)",
-            params!["struct", "Test1", "/home/user/project/src/main.rs", 10]
+            "INSERT INTO entities (kind, name, file_path, line_number, project_root) VALUES (?, ?, ?, ?, ?)",
+            params!["struct", "Test1", "/home/user/project/src/main.rs", 10, "/home/user/project"]
         )?;
 
         conn.execute(
-            "INSERT INTO entities (kind, name, file_path, line_number) VALUES (?, ?, ?, ?)",
-            params!["function", "Test2", "/var/app/lib/utils.rs", 20]
+            "INSERT INTO entities (kind, name, file_path, line_number, project_root) VALUES (?, ?, ?, ?, ?)",
+            params!["function", "Test2", "/var/app/lib/utils.rs", 20, "/var/app"]
         )?;
 
-        // Run migration
+        // Run migration (will be skipped since schema already has project_root)
         MigrationV2::run_v2_migration(&mut conn)?;
 
-        // Verify project_root extraction
+        // Verify project_root values
         let project1: String = conn.query_row(
             "SELECT project_root FROM entities WHERE name = ?",
             params!["Test1"],

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

@@ -310,14 +310,15 @@ impl QueryApi {
                 row.get::<_, Option<String>>(9)?,  // doc_comment
                 row.get::<_, Option<String>>(10)?,  // attributes
                 row.get::<_, Option<String>>(11)?,  // metadata
-                row.get::<_, i64>(12)?,          // created_at
-                row.get::<_, i64>(13)?,          // updated_at
+                row.get::<_, String>(12)?,       // project_root
+                row.get::<_, i64>(13)?,          // created_at
+                row.get::<_, i64>(14)?,          // updated_at
             ))
         })?;
 
         for row in rows {
             let row = row?;
-            let (id, kind_str, name, signature, visibility_str, parent_id, file_path, line_number, column_number, doc_comment, attributes, metadata, created_at, updated_at) = row;
+            let (id, kind_str, name, signature, visibility_str, parent_id, file_path, line_number, column_number, doc_comment, attributes, metadata, project_root, created_at, updated_at) = row;
             // For now, just create a simple entity - the full parsing can be done later
             // This is just to get the IDs for reference finding
             matching_entities.push(crate::store_v2::Entity {
@@ -333,6 +334,7 @@ impl QueryApi {
                 doc_comment,
                 attributes,
                 metadata,
+                project_root,
                 created_at: chrono::DateTime::from_timestamp(created_at, 0).unwrap_or_default(),
                 updated_at: chrono::DateTime::from_timestamp(updated_at, 0).unwrap_or_default(),
             });
@@ -366,6 +368,7 @@ impl QueryApi {
                     doc_comment: None,
                     attributes: None,
                     metadata: None,
+                    project_root: "".to_string(),
                     created_at: chrono::DateTime::from_timestamp(0, 0).unwrap_or_default(),
                     updated_at: chrono::DateTime::from_timestamp(0, 0).unwrap_or_default(),
                 };

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

@@ -226,9 +226,10 @@ impl SchemaV2 {
                 doc_comment TEXT,
                 attributes TEXT,
                 metadata TEXT,
+                project_root TEXT NOT NULL DEFAULT '',
                 created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
                 updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
-                
+
                 FOREIGN KEY (parent_id) REFERENCES entities(id) ON DELETE RESTRICT
             );
             
@@ -282,6 +283,14 @@ impl SchemaV2 {
 
                 FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE RESTRICT
             );
+
+            -- Create files table for tracking indexed files (stats and legacy compatibility)
+            CREATE TABLE IF NOT EXISTS files (
+                path TEXT PRIMARY KEY,
+                hash TEXT NOT NULL,
+                last_indexed INTEGER NOT NULL,
+                patterns_count INTEGER NOT NULL DEFAULT 0
+            );
             "#
         )?;
 
@@ -311,6 +320,8 @@ impl SchemaV2 {
             CREATE INDEX IF NOT EXISTS idx_entities_kind_name ON entities(kind, name);
             CREATE INDEX IF NOT EXISTS idx_entities_file_kind ON entities(file_path, kind);
             CREATE INDEX IF NOT EXISTS idx_entities_parent_kind ON entities(parent_id, kind);
+            CREATE INDEX IF NOT EXISTS idx_entities_project_root ON entities(project_root);
+            CREATE INDEX IF NOT EXISTS idx_entities_project_file ON entities(project_root, file_path);
             
             -- Reference indexes
             CREATE INDEX IF NOT EXISTS idx_refs_source ON refs(source_entity_id);
@@ -338,6 +349,10 @@ impl SchemaV2 {
             
             -- Entity-module relationship index (via file path)
             CREATE INDEX IF NOT EXISTS idx_entities_module_lookup ON entities(file_path);
+
+            -- Files table indexes
+            CREATE INDEX IF NOT EXISTS idx_files_hash ON files(hash);
+            CREATE INDEX IF NOT EXISTS idx_files_last_indexed ON files(last_indexed);
             "#
         )?;