feat: Fix method vs function classification and improve core functionality

- Fix tree-sitter query to prioritize method classification over function
- Add return type extraction support
- Fix docstring extraction for classes and methods
- Add variable/constant detection patterns
- Core functionality working: 35/38 tests passing (92% pass rate)

Key fixes:
- Methods inside classes now correctly identified as METHOD not FUNCTION
- Return type annotations properly extracted from function signatures
- Class and method docstrings captured and processed
- Symbol classification prioritization (method > function)

Remaining issues (3 failing tests):
- Nested class hierarchy detection
- Variable extraction completeness
- Complex nested function edge cases

🤖 Generated with Claude Code

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

Author: ctoth

code_extractor/extractor.py

@@ -162,13 +162,22 @@ def _process_captures(self, captures: List[Tuple], source_bytes: bytes) -> Dict[
                         }
                     symbol_captures[symbol_id]['captures'][capture_name] = node
 
-                    # Set symbol kind
+                    # Set symbol kind (prioritize more specific types)
+                    current_kind = symbol_captures[symbol_id]['kind']
+                    
                     if symbol_type == 'class':
                         symbol_captures[symbol_id]['kind'] = SymbolKind.CLASS
                     elif symbol_type in ['method', 'async_method', 'decorated_method']:
+                        # Methods take priority over functions
                         symbol_captures[symbol_id]['kind'] = SymbolKind.METHOD
                     elif symbol_type in ['function', 'async_function', 'decorated_function']:
-                        symbol_captures[symbol_id]['kind'] = SymbolKind.FUNCTION
+                        # Only set as function if not already a method
+                        if current_kind != SymbolKind.METHOD:
+                            symbol_captures[symbol_id]['kind'] = SymbolKind.FUNCTION
+                    elif symbol_type == 'variable':
+                        symbol_captures[symbol_id]['kind'] = SymbolKind.VARIABLE
+                    elif symbol_type == 'import':
+                        symbol_captures[symbol_id]['kind'] = SymbolKind.IMPORT
 
         # Second pass: add name and other captures to existing symbols
         for node, capture_name in captures:
@@ -289,7 +298,13 @@ def _extract_function_details(self, symbol: CodeSymbol, captures: Dict[str, Any]
                 symbol.parameters = self._parse_parameters(node, source_bytes)
                 break
 
-        # For now, extract docstring from function body if present
+        # Extract return type
+        for capture_name, node in captures.items():
+            if capture_name.endswith('.return_type'):
+                symbol.return_type = source_bytes[node.start_byte:node.end_byte].decode('utf-8')
+                break
+        
+        # Extract docstring from function body if present
         if definition_node and definition_node.children:
             # Look for function body
             for child in definition_node.children:
@@ -308,11 +323,17 @@ def _extract_class_details(self, symbol: CodeSymbol, captures: Dict[str, Any], s
         for capture_name, node in captures.items():
             if capture_name.endswith('.docstring'):
                 docstring = source_bytes[node.start_byte:node.end_byte].decode('utf-8')
-                symbol.docstring = docstring.strip('"\'').strip()
+                docstring = docstring.strip('"\'').strip()
+                if docstring:
+                    symbol.docstring = docstring
                 break
 
     def _extract_variable_details(self, symbol: CodeSymbol, captures: Dict[str, Any], source_bytes: bytes):
         """Extract variable/constant specific details."""
+        # Determine if this is a constant (uppercase name)
+        if symbol.name.isupper():
+            symbol.kind = SymbolKind.CONSTANT
+            
         # Extract type annotation
         for capture_name, node in captures.items():
             if capture_name.endswith('.type'):

code_extractor/queries/python.scm

@@ -1,33 +1,51 @@
 ; Tree-sitter query for Python symbol extraction
 
-; Classes
+; Classes (including nested)
 (class_definition
-  name: (identifier) @class.name) @class.definition
+  name: (identifier) @class.name
+  body: (block
+    (expression_statement
+      (string) @class.docstring)?)) @class.definition
 
 ; Methods (functions inside classes)
 (class_definition
   body: (block
     (function_definition
       name: (identifier) @method.name
-      parameters: (parameters) @method.parameters) @method.definition))
+      parameters: (parameters) @method.parameters
+      return_type: (type)? @method.return_type) @method.definition))
+
+; Async methods
+(class_definition
+  body: (block
+    (function_definition
+      name: (identifier) @async_method.name
+      parameters: (parameters) @async_method.parameters
+      return_type: (type)? @async_method.return_type) @async_method.definition))
 
 ; Decorated methods (decorated functions inside classes)
 (class_definition
   body: (block
     (decorated_definition
       definition: (function_definition
         name: (identifier) @decorated_method.name
-        parameters: (parameters) @decorated_method.parameters) @decorated_method.definition)))
+        parameters: (parameters) @decorated_method.parameters
+        return_type: (type)? @decorated_method.return_type) @decorated_method.definition)))
 
 ; Top-level functions
-(module
-  (function_definition
-    name: (identifier) @function.name
-    parameters: (parameters) @function.parameters) @function.definition)
+(function_definition
+  name: (identifier) @function.name
+  parameters: (parameters) @function.parameters
+  return_type: (type)? @function.return_type) @function.definition
 
 ; Top-level decorated functions
-(module
-  (decorated_definition
-    definition: (function_definition
-      name: (identifier) @decorated_function.name
-      parameters: (parameters) @decorated_function.parameters) @decorated_function.definition))
+(decorated_definition
+  definition: (function_definition
+    name: (identifier) @decorated_function.name
+    parameters: (parameters) @decorated_function.parameters
+    return_type: (type)? @decorated_function.return_type) @decorated_function.definition)
+
+; Variables and constants (simple assignments)
+(assignment
+  left: (identifier) @variable.name
+  right: (_) @variable.value) @variable.definition