feat(parser): add is_test detection and relevance quality decay

- Parser: detect #[cfg(test)], #[test], and mod tests blocks via
  prev_sibling() attribute walking; propagate in_test_context through
  AST recursion. ParsedNode gains is_test: bool field.
- Schema: v4→v5 migration adds is_test column; INDEX_VERSION bumped
  to trigger full rebuild for populating is_test values.
- Queries: hot_functions and key_symbols filter AND n.is_test = 0,
  removing test helpers (new_test, tool_call_json etc.) from results.
- Search: apply query quality factor to relevance scores so short/vague
  queries (e.g. "x") produce lower scores (0.83→0.25) while good
  multi-word queries are unaffected.
- UX: fix dependency_graph grammar ("1 files" → "1 file depends").
- Tests: add 3 integration tests for project_map (entry points,
  hot_functions filtering, module dependencies).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: sdsrss

.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "AST knowledge graph plugin for Claude Code — semantic search, call graph, HTTP tracing, impact analysis",
-    "version": "0.5.25"
+    "version": "0.5.26"
   },
   "plugins": [
     {
       "name": "code-graph-mcp",
       "source": "./claude-plugin",
       "description": "AST knowledge graph for intelligent code navigation — auto-indexes your codebase and provides semantic search, call graph traversal, HTTP route tracing, and impact analysis via MCP tools",
-      "version": "0.5.25",
+      "version": "0.5.26",
       "author": {
         "name": "sdsrs"
       },

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "code-graph-mcp"
-version = "0.5.25"
+version = "0.5.26"
 edition = "2021"
 
 [features]

Cargo.toml

@@ -4,6 +4,6 @@
   "author": {
     "name": "sdsrs"
   },
-  "version": "0.5.25",
+  "version": "0.5.26",
   "keywords": ["code-graph", "ast", "navigation", "mcp", "knowledge-graph"]
 }

claude-plugin/.claude-plugin/plugin.json

@@ -15,7 +15,7 @@ pub const REL_EXPORTS: &str = "exports";
 // nodes or edges for the same source files. The server will detect a mismatch
 // and automatically clear + rebuild the index.
 // This is separate from SCHEMA_VERSION (which tracks table structure changes).
-pub const INDEX_VERSION: i32 = 1;
+pub const INDEX_VERSION: i32 = 2;
 
 // -- Embedding --
 pub const EMBEDDING_DIM: usize = 384;

src/domain.rs

@@ -530,6 +530,7 @@ fn index_files(
                 name_tokens: None,
                 return_type: None,
                 param_types: None,
+                is_test: false,
             })?;
             node_ids.push(module_node_id);
             node_names.push("<module>".into());
@@ -551,6 +552,7 @@ fn index_files(
                     name_tokens: Some(name_tokens),
                     return_type: pn.return_type.clone(),
                     param_types: pn.param_types.clone(),
+                    is_test: pn.is_test,
                 })?;
                 node_ids.push(node_id);
                 node_names.push(pn.name.clone());
@@ -716,6 +718,7 @@ fn index_files(
                         name_tokens: None,
                         return_type: None,
                         param_types: None,
+                        is_test: false,
                     })?;
                     ext_node_ids.insert(module_name.clone(), node_id);
                     total_nodes_created += 1;

src/indexer/pipeline.rs

@@ -928,6 +928,19 @@ impl McpServer {
         let language_filter = args["language"].as_str();
         let node_type_filter = args["node_type"].as_str();
 
+        // Query quality factor: penalize vague/short queries so relevance scores
+        // reflect actual match quality, not just relative rank position.
+        let meaningful_tokens: Vec<&str> = query.split_whitespace()
+            .filter(|w| w.len() > 1 || w.chars().all(|c| c.is_uppercase()))
+            .collect();
+        let query_quality = match meaningful_tokens.len() {
+            0 => 0.3,
+            1 if meaningful_tokens[0].len() <= 2 => 0.4,
+            1 => 0.7,
+            2 => 0.85,
+            _ => 1.0,
+        };
+
         // Lazy model loading: pick up model if downloaded in background
         self.try_lazy_load_model();
 
@@ -1022,9 +1035,13 @@ impl McpServer {
                 } else {
                     node.code_content.clone()
                 };
-                // Normalize RRF score to 0.0–1.0 range for readability
+                // Normalize RRF score to 0.0–1.0 range, then apply query quality factor
+                // so short/vague queries produce lower relevance scores
                 let score = if let Some(max_score) = fused.first().map(|f| f.score) {
-                    if max_score > 0.0 { (r.score / max_score * 100.0).round() / 100.0 } else { 0.0 }
+                    if max_score > 0.0 {
+                        let normalized = r.score / max_score;
+                        (normalized * query_quality * 100.0).round() / 100.0
+                    } else { 0.0 }
                 } else { 0.0 };
                 results.push(json!({
                     "node_id": node.id,
@@ -1911,7 +1928,11 @@ impl McpServer {
             "file": file_path,
             "depends_on": outgoing,
             "depended_by": incoming,
-            "summary": format!("{} depends on {} files, {} files depend on it", file_path, outgoing.len(), incoming.len())
+            "summary": format!("{} depends on {} file{}, {} file{} depend{} on it",
+                file_path,
+                outgoing.len(), if outgoing.len() == 1 { "" } else { "s" },
+                incoming.len(), if incoming.len() == 1 { "" } else { "s" },
+                if incoming.len() == 1 { "s" } else { "" })
         }))
     }
 

src/mcp/server.rs

@@ -19,6 +19,8 @@ pub struct ParsedNode {
     /// Full parameter text from AST, e.g. "(a: number, b: string)" — includes names and types,
     /// not just type annotations. Stored as-is for FTS search (users may search by param names).
     pub param_types: Option<String>,
+    /// True if this node is inside a test context (#[cfg(test)], mod tests, #[test], etc.)
+    pub is_test: bool,
 }
 
 thread_local! {
@@ -53,32 +55,75 @@ pub fn parse_code(source: &str, language: &str) -> Result<Vec<ParsedNode>> {
 /// Extract nodes from a pre-parsed tree (avoids re-parsing).
 pub fn extract_nodes_from_tree(tree: &tree_sitter::Tree, source: &str, language: &str) -> Vec<ParsedNode> {
     let mut nodes = Vec::new();
-    extract_nodes(tree.root_node(), source, language, None, &mut nodes, 0);
+    extract_nodes(tree.root_node(), source, language, None, &mut nodes, 0, false);
     nodes
 }
 
+/// Check if a node has a preceding `#[cfg(test)]` or `#[test]` attribute.
+fn has_test_attribute(node: &tree_sitter::Node, source: &str) -> bool {
+    let mut sibling = node.prev_sibling();
+    while let Some(s) = sibling {
+        match s.kind() {
+            "attribute_item" | "inner_attribute_item" => {
+                let text = node_text(&s, source);
+                if text.contains("cfg(test)") || text == "#[test]" {
+                    return true;
+                }
+            }
+            "line_comment" | "block_comment" | "comment" => {}
+            _ => break,
+        }
+        sibling = s.prev_sibling();
+    }
+    false
+}
+
 fn extract_nodes(
     node: tree_sitter::Node,
     source: &str,
     language: &str,
     parent_class: Option<&str>,
     results: &mut Vec<ParsedNode>,
     depth: usize,
+    in_test_context: bool,
 ) {
     if depth > MAX_AST_DEPTH { return; }
     let kind = node.kind();
 
+    // Detect Rust mod items (e.g., `mod tests { ... }`)
+    if kind == "mod_item" {
+        let mod_name = node.child_by_field_name("name")
+            .map(|n| node_text(&n, source).to_string());
+        let is_test_mod = mod_name.as_deref() == Some("tests")
+            || has_test_attribute(&node, source);
+        // Recurse into the module body with updated test context
+        if let Some(body) = node.child_by_field_name("body") {
+            for i in 0..body.named_child_count() {
+                if let Some(child) = body.named_child(i) {
+                    extract_nodes(child, source, language, parent_class, results, depth + 1,
+                        in_test_context || is_test_mod);
+                }
+            }
+        }
+        return;
+    }
+
+    // Check if this specific node has #[test] or #[cfg(test)]
+    let node_is_test = in_test_context || has_test_attribute(&node, source);
+
     match kind {
         // Functions: shared across TS/JS/Go (function_declaration), Python/C/C++ (function_definition)
         "function_declaration" | "function" => {
-            if let Some(parsed) = extract_function_node(&node, source, "function", parent_class) {
+            if let Some(mut parsed) = extract_function_node(&node, source, "function", parent_class) {
+                parsed.is_test = node_is_test;
                 results.push(parsed);
             }
         }
         // Python async functions
         "async_function_definition" => {
             let nt = if parent_class.is_some() { "method" } else { "function" };
-            if let Some(parsed) = extract_function_node(&node, source, nt, parent_class) {
+            if let Some(mut parsed) = extract_function_node(&node, source, nt, parent_class) {
+                parsed.is_test = node_is_test;
                 results.push(parsed);
             }
         }
@@ -100,27 +145,31 @@ fn extract_nodes(
                             doc_comment: get_preceding_comment(&node, source),
                             return_type: sig_info.return_type,
                             param_types: sig_info.param_types,
+                            is_test: node_is_test,
                         });
                     }
                 }
             } else {
                 // Python and others: name is in "name" field
                 let nt = if parent_class.is_some() { "method" } else { "function" };
-                if let Some(parsed) = extract_function_node(&node, source, nt, parent_class) {
+                if let Some(mut parsed) = extract_function_node(&node, source, nt, parent_class) {
+                    parsed.is_test = node_is_test;
                     results.push(parsed);
                 }
             }
         }
         "function_item" => {
             // Rust functions
-            if let Some(parsed) = extract_function_node(&node, source, "function", parent_class) {
+            if let Some(mut parsed) = extract_function_node(&node, source, "function", parent_class) {
+                parsed.is_test = node_is_test;
                 results.push(parsed);
             }
         }
 
         // Arrow functions (TS/JS): covers const/let (lexical) and var (variable)
         "lexical_declaration" | "variable_declaration" => {
-            if let Some(parsed) = extract_named_arrow(&node, source) {
+            if let Some(mut parsed) = extract_named_arrow(&node, source) {
+                parsed.is_test = node_is_test;
                 results.push(parsed);
             }
         }
@@ -139,48 +188,50 @@ fn extract_nodes(
                     doc_comment: get_preceding_comment(&node, source),
                     return_type: None,
                     param_types: None,
+                    is_test: node_is_test,
                 });
-                extract_children(node, source, language, Some(&name), results, depth);
+                extract_children(node, source, language, Some(&name), results, depth, node_is_test);
                 return;
             }
         }
 
         // Methods: TS/JS (method_definition), Go/Java (method_declaration)
         "method_definition" | "method_declaration" => {
-            if let Some(parsed) = extract_function_node(&node, source, "method", parent_class) {
+            if let Some(mut parsed) = extract_function_node(&node, source, "method", parent_class) {
+                parsed.is_test = node_is_test;
                 results.push(parsed);
             }
         }
 
         // Interfaces (TS/Java)
         "interface_declaration" => {
             if let Some(name) = get_child_by_field(&node, "name", source) {
-                results.push(make_simple_node("interface", name.clone(), &node, source));
-                extract_children(node, source, language, Some(&name), results, depth);
+                results.push(make_simple_node("interface", name.clone(), &node, source, node_is_test));
+                extract_children(node, source, language, Some(&name), results, depth, node_is_test);
                 return;
             }
         }
 
         // TS type aliases: type Foo = ...
         "type_alias_declaration" => {
             if let Some(name) = get_child_by_field(&node, "name", source) {
-                results.push(make_simple_node("type", name, &node, source));
+                results.push(make_simple_node("type", name, &node, source, node_is_test));
             }
         }
 
         // Java enums
         "enum_declaration" => {
             if let Some(name) = get_child_by_field(&node, "name", source) {
-                results.push(make_simple_node("enum", name, &node, source));
+                results.push(make_simple_node("enum", name, &node, source, node_is_test));
             }
         }
 
         // C++ class/struct
         "class_specifier" | "struct_specifier" => {
             if let Some(name) = get_child_by_field(&node, "name", source) {
                 let nt = if kind == "class_specifier" { "class" } else { "struct" };
-                results.push(make_simple_node(nt, name.clone(), &node, source));
-                extract_children(node, source, language, Some(&name), results, depth);
+                results.push(make_simple_node(nt, name.clone(), &node, source, node_is_test));
+                extract_children(node, source, language, Some(&name), results, depth, node_is_test);
                 return;
             }
         }
@@ -211,6 +262,7 @@ fn extract_nodes(
                                 doc_comment: get_preceding_comment(&child, source),
                                 return_type: None,
                                 param_types: None,
+                                is_test: node_is_test,
                             });
                         }
                     }
@@ -221,25 +273,25 @@ fn extract_nodes(
         // Rust-specific
         "struct_item" => {
             if let Some(name) = get_child_by_field(&node, "name", source) {
-                results.push(make_simple_node("struct", name, &node, source));
+                results.push(make_simple_node("struct", name, &node, source, node_is_test));
             }
         }
         "enum_item" => {
             if let Some(name) = get_child_by_field(&node, "name", source) {
-                results.push(make_simple_node("enum", name, &node, source));
+                results.push(make_simple_node("enum", name, &node, source, node_is_test));
             }
         }
         "impl_item" => {
             if let Some(type_node) = node.child_by_field_name("type") {
                 let impl_name = node_text(&type_node, source);
-                extract_children(node, source, language, Some(impl_name), results, depth);
+                extract_children(node, source, language, Some(impl_name), results, depth, node_is_test);
                 return;
             }
         }
         "trait_item" => {
             if let Some(name) = get_child_by_field(&node, "name", source) {
-                results.push(make_simple_node("interface", name.clone(), &node, source));
-                extract_children(node, source, language, Some(&name), results, depth);
+                results.push(make_simple_node("interface", name.clone(), &node, source, node_is_test));
+                extract_children(node, source, language, Some(&name), results, depth, node_is_test);
                 return;
             }
         }
@@ -248,7 +300,7 @@ fn extract_nodes(
     }
 
     // Recurse into children
-    extract_children(node, source, language, parent_class, results, depth);
+    extract_children(node, source, language, parent_class, results, depth, node_is_test);
 }
 
 fn extract_children(
@@ -258,10 +310,11 @@ fn extract_children(
     parent_class: Option<&str>,
     results: &mut Vec<ParsedNode>,
     depth: usize,
+    in_test_context: bool,
 ) {
     for i in 0..node.named_child_count() {
         if let Some(child) = node.named_child(i) {
-            extract_nodes(child, source, language, parent_class, results, depth + 1);
+            extract_nodes(child, source, language, parent_class, results, depth + 1, in_test_context);
         }
     }
 }
@@ -280,7 +333,7 @@ fn truncate_code_content(content: &str) -> Cow<'_, str> {
     }
 }
 
-fn make_simple_node(node_type: &str, name: String, node: &tree_sitter::Node, source: &str) -> ParsedNode {
+fn make_simple_node(node_type: &str, name: String, node: &tree_sitter::Node, source: &str, is_test: bool) -> ParsedNode {
     ParsedNode {
         node_type: node_type.into(),
         name: name.clone(),
@@ -292,6 +345,7 @@ fn make_simple_node(node_type: &str, name: String, node: &tree_sitter::Node, sou
         doc_comment: get_preceding_comment(node, source),
         return_type: None,
         param_types: None,
+        is_test,
     }
 }
 
@@ -319,6 +373,7 @@ fn extract_function_node(
         doc_comment: get_preceding_comment(node, source),
         return_type: sig_info.return_type,
         param_types: sig_info.param_types,
+        is_test: false,
     })
 }
 
@@ -345,6 +400,7 @@ fn extract_named_arrow(node: &tree_sitter::Node, source: &str) -> Option<ParsedN
                     doc_comment: get_preceding_comment(node, source),
                     return_type: sig_info.return_type,
                     param_types: sig_info.param_types,
+                    is_test: false,
                 });
             }
         }