feat: add symbol-definitions search type to search_code_tool

- Add new search type "symbol-definitions" alongside existing "function-calls"
- Support finding function, class, and variable definitions in Python/JS/TS
- Include rich metadata with symbol_type classification
- Enhance search_code_tool documentation with examples and use cases
- Doubles search capability: find where symbols are DEFINED vs USED

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ctoth

code_extractor/search_engine.py

@@ -45,9 +45,11 @@ def search_file(self, file_path: str, params: SearchParameters) -> List[SearchRe
             parser = get_parser(lang_name)
             tree = parser.parse(source_code.encode('utf-8'))
 
-            # For Phase 1, we'll hardcode the function-calls pattern
+            # Route to appropriate search method
             if params.search_type == "function-calls":
                 return self._search_function_calls(file_path, source_code, tree, params, lang_name)
+            elif params.search_type == "symbol-definitions":
+                return self._search_symbol_definitions(file_path, source_code, tree, params, lang_name)
 
             return []
 
@@ -189,6 +191,144 @@ def _search_function_calls(self, file_path: str, source_code: str, tree: Any,
 
         return results
 
+    def _search_symbol_definitions(self, file_path: str, source_code: str, tree: Any, 
+                                 params: SearchParameters, lang_name: str) -> List[SearchResult]:
+        """Search for symbol definitions (classes, functions, variables) in the parsed tree."""
+        results = []
+        
+        # Define query patterns for different languages
+        patterns = {
+            'python': '''
+                ; Function definitions
+                (function_definition
+                  name: (identifier) @function_name
+                ) @function_def
+                
+                ; Class definitions
+                (class_definition
+                  name: (identifier) @class_name
+                ) @class_def
+                
+                ; Variable assignments
+                (assignment
+                  left: (identifier) @variable_name
+                ) @variable_def
+            ''',
+            'javascript': '''
+                ; Function declarations
+                (function_declaration
+                  name: (identifier) @function_name
+                ) @function_def
+                
+                ; Class declarations
+                (class_declaration
+                  name: (identifier) @class_name
+                ) @class_def
+                
+                ; Variable declarations
+                (variable_declaration
+                  (variable_declarator
+                    name: (identifier) @variable_name
+                  )
+                ) @variable_def
+                
+                ; Const declarations
+                (lexical_declaration
+                  (variable_declarator
+                    name: (identifier) @variable_name
+                  )
+                ) @const_def
+            ''',
+            'typescript': '''
+                ; Function declarations
+                (function_declaration
+                  name: (identifier) @function_name
+                ) @function_def
+                
+                ; Class declarations
+                (class_declaration
+                  name: (identifier) @class_name
+                ) @class_def
+                
+                ; Interface declarations
+                (interface_declaration
+                  name: (type_identifier) @interface_name
+                ) @interface_def
+                
+                ; Type alias declarations
+                (type_alias_declaration
+                  name: (type_identifier) @type_name
+                ) @type_def
+                
+                ; Variable declarations
+                (variable_declaration
+                  (variable_declarator
+                    name: (identifier) @variable_name
+                  )
+                ) @variable_def
+                
+                ; Const declarations
+                (lexical_declaration
+                  (variable_declarator
+                    name: (identifier) @variable_name
+                  )
+                ) @const_def
+            '''
+        }
+        
+        pattern = patterns.get(lang_name)
+        if not pattern:
+            return []
+        
+        # Compile and execute query
+        query = self._get_compiled_query(lang_name, pattern)
+        captures = query.captures(tree.root_node)
+        
+        source_lines = source_code.splitlines()
+        
+        for node, capture_name in captures:
+            if capture_name.endswith('_def'):
+                # Check if this symbol name matches our target
+                symbol_text = source_code[node.start_byte:node.end_byte]
+                
+                # For symbol definitions, we want to check if the target appears in the symbol
+                if params.target in symbol_text:
+                    start_line = node.start_point[0] + 1
+                    end_line = node.end_point[0] + 1
+                    
+                    # Get context lines
+                    context_before = []
+                    context_after = []
+                    if params.include_context:
+                        start_ctx = max(0, start_line - 1 - params.context_lines)
+                        end_ctx = min(len(source_lines), end_line + params.context_lines)
+                        context_before = source_lines[start_ctx:start_line-1]
+                        context_after = source_lines[end_line:end_ctx]
+                    
+                    # Determine symbol type from capture name
+                    symbol_type = capture_name.replace('_def', '').replace('_name', '')
+                    
+                    result = SearchResult(
+                        file_path=file_path,
+                        start_line=start_line,
+                        end_line=end_line,
+                        match_text=symbol_text,
+                        context_before=context_before,
+                        context_after=context_after,
+                        metadata={
+                            "search_type": params.search_type, 
+                            "target": params.target,
+                            "symbol_type": symbol_type
+                        },
+                        language=lang_name
+                    )
+                    results.append(result)
+                    
+                    if len(results) >= params.max_results:
+                        break
+        
+        return results
+    
     def _get_compiled_query(self, language: str, pattern: str) -> Query:
         """Get or compile a tree-sitter query."""
         cache_key = f"{language}:{hash(pattern)}"

code_extractor/server.py

@@ -554,11 +554,23 @@ def search_code_tool(
         
         Finds complex code patterns based on structure, not just text matching.
         Automatically detects whether scope is a file or directory and searches accordingly.
-        Currently supports 'function-calls' search type.
+        Supports 'function-calls' and 'symbol-definitions' search types.
+        
+        Search Types:
+        - "function-calls": Find where functions/methods are called or invoked
+        - "symbol-definitions": Find where symbols (functions, classes, variables) are defined
+        
+        Examples:
+        - Find function calls: search_type="function-calls", target="requests.get"
+        - Find function definitions: search_type="symbol-definitions", target="process_data"
+        - Find class definitions: search_type="symbol-definitions", target="UserService"
+        - Find variable definitions: search_type="symbol-definitions", target="API_KEY"
+        
+        Supported Languages: Python, JavaScript, TypeScript (with fallback for others)
         
         Args:
-            search_type: Type of search ("function-calls") 
-            target: What to search for (e.g., "requests.get", "logger.error")
+            search_type: Type of search ("function-calls", "symbol-definitions") 
+            target: What to search for (symbol name or call pattern)
             scope: File path, directory path, or URL to search in
             language: Programming language (auto-detected if not specified)
             git_revision: Optional git revision (commit, branch, tag) - not supported for URLs
@@ -568,10 +580,14 @@ def search_code_tool(
             exclude_patterns: File patterns to exclude (e.g., ["*.pyc", "node_modules/*"])
             max_files: Maximum number of files to search in directory mode
             follow_symlinks: Whether to follow symbolic links in directory search
+            
+        Returns:
+            List of search results with file paths, line numbers, matched text, context,
+            and metadata including symbol_type for definitions.
         """
         try:
             # Validate search type
-            supported_types = ["function-calls"]
+            supported_types = ["function-calls", "symbol-definitions"]
             if search_type not in supported_types:
                 return [{"error": f"Unsupported search type '{search_type}'. Supported: {supported_types}"}]