extract_function_info.py

#!/usr/bin/env python3
"""
Function Information Extraction Pipeline

This script extracts comprehensive function information from Python game repositories
including signatures, bodies, metadata, and structural analysis for future processing.
"""

import ast
import os
import sys
import json
import hashlib
import subprocess
from typing import Dict, List, Any, Optional, Tuple, Union
from dataclasses import dataclass, asdict
from pathlib import Path
from datetime import datetime
import argparse
from tqdm import tqdm

try:
    from tree_sitter import Language, Parser
    import tree_sitter_cpp
    import tree_sitter_c
    TREE_SITTER_AVAILABLE = True
except ImportError:
    TREE_SITTER_AVAILABLE = False


@dataclass
class FunctionInfo:
    """Container for extracted function information"""
    name: str
    signature: str
    body: str
    docstring: Optional[str]
    line_start: int
    line_end: int
    column_offset: int
    parameters: List[Dict[str, Any]]
    return_annotation: Optional[str]
    decorators: List[str]
    is_async: bool
    is_method: bool
    is_static_method: bool
    is_class_method: bool
    complexity_score: int
    calls_made: List[str]
    variables_used: List[str]
    control_structures: List[str]
    imports_used: List[str]


@dataclass
class ClassInfo:
    """Container for class information"""
    name: str
    line_start: int
    line_end: int
    docstring: Optional[str]
    base_classes: List[str]
    methods: List[str]
    class_variables: List[str]
    decorators: List[str]


@dataclass
class FileInfo:
    """Container for complete file analysis"""
    file_path: str
    relative_path: str
    repository: str
    file_size: int
    line_count: int
    file_hash: str
    encoding: str
    imports: List[Dict[str, str]]
    global_variables: List[Dict[str, Any]]
    functions: List[FunctionInfo]
    classes: List[ClassInfo]
    main_execution_block: Optional[str]
    complexity_metrics: Dict[str, Any]
    ast_valid: bool
    extraction_timestamp: str


class FunctionExtractor:
    """Advanced function and code structure extractor"""
    
    def __init__(self, base_directory: str = "repos_GAME_python_demo", min_lines: int = 28):
        """Initialize the extractor"""
        self.base_directory = Path(base_directory)
        self.python_extensions = {'.py'}
        self.ts_extensions = {'.ts', '.tsx', '.js', '.jsx'}
        self.cpp_extensions = {'.cpp', '.cc', '.cxx', '.hpp'}  # .h is handled with heuristic
        self.c_extensions = {'.c'}
        self.excluded_files = {'__pycache__', '.git', '.gitignore', 'requirements.txt', 'setup.py'}
        self.excluded_dirs = {'__pycache__', '.git', '.github', 'node_modules', 'venv', 'env'}
        self.min_lines = min_lines
        self.ts_extractor_script = Path(__file__).parent / "extract_ts_info.js"
        self.failed_files = []  # Track failed files
        
        self.cpp_parser = None
        self.c_parser = None
        if TREE_SITTER_AVAILABLE:
            try:
                self.cpp_language = Language(tree_sitter_cpp.language())
                self.cpp_parser = Parser(self.cpp_language)
                
                self.c_language = Language(tree_sitter_c.language())
                self.c_parser = Parser(self.c_language)
            except Exception as e:
                print(f"Failed to initialize tree-sitter: {e}")
        
    def safe_unparse(self, node: ast.AST) -> str:
        """Safely unparse AST node"""
        try:
            if hasattr(ast, 'unparse'):
                return ast.unparse(node)
            else:
                # Fallback for older Python versions
                import astor
                return astor.to_source(node).strip()
        except:
            return 'complex_expression'
    
    def calculate_complexity_score(self, node: ast.AST) -> int:
        """Calculate cyclomatic complexity of a function"""
        complexity = 1  # Base complexity
        
        for child in ast.walk(node):
            # Decision points that increase complexity
            if isinstance(child, (ast.If, ast.While, ast.For, ast.AsyncFor)):
                complexity += 1
            elif isinstance(child, ast.ExceptHandler):
                complexity += 1
            elif isinstance(child, (ast.And, ast.Or)):
                complexity += 1
            elif isinstance(child, ast.comprehension):
                complexity += 1
        
        return complexity
    
    def extract_function_calls(self, node: ast.AST) -> List[str]:
        """Extract function calls made within a function"""
        calls = []
        
        for child in ast.walk(node):
            if isinstance(child, ast.Call):
                if isinstance(child.func, ast.Name):
                    calls.append(child.func.id)
                elif isinstance(child.func, ast.Attribute):
                    # Handle method calls like obj.method()
                    if isinstance(child.func.value, ast.Name):
                        calls.append(f"{child.func.value.id}.{child.func.attr}")
                    else:
                        calls.append(child.func.attr)
        
        return list(set(calls))  # Remove duplicates
    
    def extract_variables_used(self, node: ast.AST) -> List[str]:
        """Extract variables referenced in a function"""
        variables = []
        
        for child in ast.walk(node):
            if isinstance(child, ast.Name) and isinstance(child.ctx, ast.Load):
                variables.append(child.id)
        
        return list(set(variables))
    
    def extract_control_structures(self, node: ast.AST) -> List[str]:
        """Extract control flow structures used"""
        structures = []
        
        for child in ast.walk(node):
            if isinstance(child, ast.If):
                structures.append('if')
            elif isinstance(child, ast.While):
                structures.append('while')
            elif isinstance(child, ast.For):
                structures.append('for')
            elif isinstance(child, ast.Try):
                structures.append('try')
            elif isinstance(child, ast.With):
                structures.append('with')
            elif isinstance(child, ast.AsyncFor):
                structures.append('async_for')
            elif isinstance(child, ast.AsyncWith):
                structures.append('async_with')
        
        return list(set(structures))
    
    def extract_function_parameters(self, func_node: Union[ast.FunctionDef, ast.AsyncFunctionDef]) -> List[Dict[str, Any]]:
        """Extract detailed parameter information"""
        parameters = []
        
        # Regular arguments
        for i, arg in enumerate(func_node.args.args):
            param_info = {
                'name': arg.arg,
                'type_annotation': self.safe_unparse(arg.annotation) if arg.annotation else None,
                'position': i,
                'kind': 'positional',
                'default': None
            }
            
            # Check for default values
            defaults_offset = len(func_node.args.args) - len(func_node.args.defaults)
            if i >= defaults_offset:
                default_idx = i - defaults_offset
                param_info['default'] = self.safe_unparse(func_node.args.defaults[default_idx])
            
            parameters.append(param_info)
        
        # *args parameter
        if func_node.args.vararg:
            parameters.append({
                'name': func_node.args.vararg.arg,
                'type_annotation': self.safe_unparse(func_node.args.vararg.annotation) if func_node.args.vararg.annotation else None,
                'position': len(parameters),
                'kind': 'var_positional',
                'default': None
            })
        
        # Keyword-only arguments
        for i, arg in enumerate(func_node.args.kwonlyargs):
            param_info = {
                'name': arg.arg,
                'type_annotation': self.safe_unparse(arg.annotation) if arg.annotation else None,
                'position': len(parameters),
                'kind': 'keyword_only',
                'default': None
            }
            
            # Check for keyword defaults
            if i < len(func_node.args.kw_defaults) and func_node.args.kw_defaults[i]:
                param_info['default'] = self.safe_unparse(func_node.args.kw_defaults[i])
            
            parameters.append(param_info)
        
        # **kwargs parameter
        if func_node.args.kwarg:
            parameters.append({
                'name': func_node.args.kwarg.arg,
                'type_annotation': self.safe_unparse(func_node.args.kwarg.annotation) if func_node.args.kwarg.annotation else None,
                'position': len(parameters),
                'kind': 'var_keyword',
                'default': None
            })
        
        return parameters
    
    def extract_decorators(self, node: Union[ast.FunctionDef, ast.AsyncFunctionDef]) -> List[str]:
        """Extract decorator information"""
        decorators = []
        
        for decorator in node.decorator_list:
            try:
                decorators.append(self.safe_unparse(decorator))
            except:
                # Fallback for complex decorators
                if isinstance(decorator, ast.Name):
                    decorators.append(decorator.id)
                else:
                    decorators.append('complex_decorator')
        
        return decorators
    
    def is_method_type(self, func_node: Union[ast.FunctionDef, ast.AsyncFunctionDef], class_context: bool = False) -> Tuple[bool, bool, bool]:
        """Determine if function is method, static method, or class method"""
        is_method = class_context
        is_static = False
        is_class = False
        
        if class_context:
            decorators = self.extract_decorators(func_node)
            is_static = any('staticmethod' in dec for dec in decorators)
            is_class = any('classmethod' in dec for dec in decorators)
        
        return is_method, is_static, is_class
    
    def extract_function_info(self, func_node: Union[ast.FunctionDef, ast.AsyncFunctionDef], source_lines: List[str], 
                            class_context: bool = False) -> FunctionInfo:
        """Extract comprehensive information about a function"""
        
        # Basic information
        name = func_node.name
        line_start = func_node.lineno
        line_end = getattr(func_node, 'end_lineno', line_start)
        column_offset = func_node.col_offset
        
        # Extract function body
        body_lines = source_lines[line_start-1:line_end]
        body = '\n'.join(body_lines)
        
        # Generate signature
        try:
            # Create a simple signature representation
            params = []
            for arg in func_node.args.args:
                param_str = arg.arg
                if arg.annotation:
                    param_str += f": {self.safe_unparse(arg.annotation)}"
                params.append(param_str)
            
            if func_node.args.vararg:
                param_str = f"*{func_node.args.vararg.arg}"
                if func_node.args.vararg.annotation:
                    param_str += f": {self.safe_unparse(func_node.args.vararg.annotation)}"
                params.append(param_str)
            
            if func_node.args.kwarg:
                param_str = f"**{func_node.args.kwarg.arg}"
                if func_node.args.kwarg.annotation:
                    param_str += f": {self.safe_unparse(func_node.args.kwarg.annotation)}"
                params.append(param_str)
            
            signature = f"def {name}({', '.join(params)})"
            if func_node.returns:
                signature += f" -> {self.safe_unparse(func_node.returns)}"
        except:
            signature = f"def {name}(...)"  # Fallback
        
        # Extract detailed information
        parameters = self.extract_function_parameters(func_node)
        decorators = self.extract_decorators(func_node)
        is_method, is_static_method, is_class_method = self.is_method_type(func_node, class_context)
        
        return FunctionInfo(
            name=name,
            signature=signature,
            body=body,
            docstring=ast.get_docstring(func_node),
            line_start=line_start,
            line_end=line_end,
            column_offset=column_offset,
            parameters=parameters,
            return_annotation=self.safe_unparse(func_node.returns) if func_node.returns else None,
            decorators=decorators,
            is_async=isinstance(func_node, ast.AsyncFunctionDef),
            is_method=is_method,
            is_static_method=is_static_method,
            is_class_method=is_class_method,
            complexity_score=self.calculate_complexity_score(func_node),
            calls_made=self.extract_function_calls(func_node),
            variables_used=self.extract_variables_used(func_node),
            control_structures=self.extract_control_structures(func_node),
            imports_used=[]  # Will be populated during file-level analysis
        )
    
    def extract_class_info(self, class_node: ast.ClassDef, source_lines: List[str]) -> ClassInfo:
        """Extract information about a class"""
        
        return ClassInfo(
            name=class_node.name,
            line_start=class_node.lineno,
            line_end=getattr(class_node, 'end_lineno', class_node.lineno),
            docstring=ast.get_docstring(class_node),
            base_classes=[self.safe_unparse(base) for base in class_node.bases],
            methods=[node.name for node in class_node.body if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))],
            class_variables=[node.targets[0].id for node in class_node.body 
                           if isinstance(node, ast.Assign) and isinstance(node.targets[0], ast.Name)],
            decorators=[self.safe_unparse(dec) for dec in class_node.decorator_list]
        )
    
    def extract_imports(self, tree: ast.AST) -> List[Dict[str, str]]:
        """Extract import information"""
        imports = []
        
        for node in ast.walk(tree):
            if isinstance(node, ast.Import):
                for alias in node.names:
                    imports.append({
                        'type': 'import',
                        'module': alias.name,
                        'alias': alias.asname,
                        'line': node.lineno
                    })
            elif isinstance(node, ast.ImportFrom):
                module = node.module or ''
                for alias in node.names:
                    imports.append({
                        'type': 'from_import',
                        'module': module,
                        'name': alias.name,
                        'alias': alias.asname,
                        'line': node.lineno,
                        'level': node.level
                    })
        
        return imports
    
    def extract_global_variables(self, tree: ast.AST) -> List[Dict[str, Any]]:
        """Extract global variable definitions"""
        variables = []
        
        for node in tree.body:
            if isinstance(node, ast.Assign):
                for target in node.targets:
                    if isinstance(target, ast.Name):
                        variables.append({
                            'name': target.id,
                            'line': node.lineno,
                            'value': self.safe_unparse(node.value)
                        })
        
        return variables
    
    def extract_main_execution(self, tree: ast.AST, source_lines: List[str]) -> Optional[str]:
        """Extract main execution block (if __name__ == '__main__')"""
        for node in tree.body:
            if (isinstance(node, ast.If) and 
                isinstance(node.test, ast.Compare) and
                isinstance(node.test.left, ast.Name) and
                node.test.left.id == '__name__'):
                
                # Extract the main block
                start_line = node.lineno - 1
                end_line = getattr(node, 'end_lineno', len(source_lines))
                return '\n'.join(source_lines[start_line:end_line])
        
        return None
    
    def calculate_file_complexity(self, functions: List[FunctionInfo], classes: List[ClassInfo]) -> Dict[str, Any]:
        """Calculate overall file complexity metrics"""
        if not functions:
            return {
                'total_functions': 0,
                'total_classes': len(classes),
                'avg_function_complexity': 0,
                'max_function_complexity': 0,
                'total_lines_of_code': 0
            }
        
        complexities = [f.complexity_score for f in functions]
        
        return {
            'total_functions': len(functions),
            'total_classes': len(classes),
            'avg_function_complexity': sum(complexities) / len(complexities),
            'max_function_complexity': max(complexities),
            'total_lines_of_code': sum(f.line_end - f.line_start + 1 for f in functions)
        }
    
    def is_function_body_long_enough(self, func_node: Union[ast.FunctionDef, ast.AsyncFunctionDef], min_lines: int = 28) -> bool:
        """Check if function body has enough lines of code (excluding docstring and decorators)"""
        # Get line numbers safely
        start_line = getattr(func_node, 'lineno', 0)
        end_line = getattr(func_node, 'end_lineno', 0)
        
        if not start_line or not end_line:
            return False
            
        # Calculate total lines
        total_lines = end_line - start_line + 1
        
        # Subtract docstring if present
        docstring = ast.get_docstring(func_node)
        if docstring:
            # Docstring typically takes 3 lines (""" ... """)
            total_lines = max(0, total_lines - 3)
            
        # Subtract decorator lines
        total_lines = max(0, total_lines - len(func_node.decorator_list))
            
        # Subtract 1 for the function definition line
        total_lines = max(0, total_lines - 1)
        
        return total_lines >= min_lines

    def analyze_python_file(self, file_path: Path) -> Optional[FileInfo]:
        """Analyze a single Python file and extract all information"""
        try:
            # Read file content
            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                content = f.read()
                source_lines = content.splitlines()
            
            # Calculate file metadata
            file_size = file_path.stat().st_size
            file_hash = hashlib.sha256(content.encode('utf-8')).hexdigest()
            relative_path = str(file_path.relative_to(self.base_directory))
            repository = relative_path.split('/')[0] if '/' in relative_path else "unknown"
            
            # Parse AST
            try:
                tree = ast.parse(content)
                ast_valid = True
            except SyntaxError as e:
                print(f"Syntax error in {file_path}: {e}")
                self.failed_files.append({
                    'file_path': str(file_path),
                    'error': str(e),
                    'content': content
                })
                return None
            
            # Extract functions and classes
            functions = []
            classes = []
            
            for node in tree.body:
                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
                    # Skip functions with small bodies
                    if self.is_function_body_long_enough(node, self.min_lines):
                        func_info = self.extract_function_info(node, source_lines)
                        functions.append(func_info)
                elif isinstance(node, ast.ClassDef):
                    class_info = self.extract_class_info(node, source_lines)
                    classes.append(class_info)
                    
                    # Extract methods from class
                    for class_node in node.body:
                        if isinstance(class_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
                            # Skip methods with small bodies
                            if self.is_function_body_long_enough(class_node, self.min_lines):
                                method_info = self.extract_function_info(class_node, source_lines, class_context=True)
                                functions.append(method_info)
            
            # Skip files with no substantial functions
            if not functions and not classes:
                return None
                
            # Extract other information
            imports = self.extract_imports(tree)
            global_variables = self.extract_global_variables(tree)
            main_execution = self.extract_main_execution(tree, source_lines)
            complexity_metrics = self.calculate_file_complexity(functions, classes)
            
            # Link imports to functions (simplified approach)
            import_names = {imp['module'] for imp in imports if imp['type'] == 'import'}
            import_names.update({imp['name'] for imp in imports if imp['type'] == 'from_import'})
            
            for func in functions:
                func.imports_used = [imp for imp in import_names if any(imp in call for call in func.calls_made)]
            
            return FileInfo(
                file_path=str(file_path),
                relative_path=relative_path,
                repository=repository,
                file_size=file_size,
                line_count=len(source_lines),
                file_hash=file_hash,
                encoding='utf-8',
                imports=imports,
                global_variables=global_variables,
                functions=functions,
                classes=classes,
                main_execution_block=main_execution,
                complexity_metrics=complexity_metrics,
                ast_valid=ast_valid,
                extraction_timestamp=datetime.now().isoformat()
            )
            
        except Exception as e:
            print(f"Error analyzing file {file_path}: {e}")
            # Try to read content if possible, otherwise empty
            try:
                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                    content = f.read()
            except:
                content = "Could not read content"
                
            self.failed_files.append({
                'file_path': str(file_path),
                'error': str(e),
                'content': content
            })
            return None

    def analyze_cpp_file(self, file_path: Path) -> Optional[FileInfo]:
        """Analyze a single C++ file using tree-sitter"""
        if not self.cpp_parser:
            print(f"Skipping C++ file {file_path}: tree-sitter-cpp not initialized")
            return None
            
        try:
            # Read file content
            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                content = f.read()
                content_bytes = content.encode('utf-8')
            
            # Use tree-sitter to parse
            tree = self.cpp_parser.parse(content_bytes)
            
            # Find functions and classes
            functions = []
            classes = []
            
            cursor = tree.walk()
            
            def traverse(node, class_context=False):
                # Handle Functions
                if node.type == 'function_definition' or node.type == 'template_declaration':
                    # If template, look inside for function_definition
                    target_node = node
                    if node.type == 'template_declaration':
                        # Find the underlying declaration
                        for child in node.children:
                            if child.type == 'function_definition':
                                target_node = child
                                break
                        else:
                             # Skip independent template declarations (like class templates, which are handled below)
                             pass
                    
                    if target_node.type == 'function_definition':
                        func_info = self._extract_cpp_function_info(target_node, content, content_bytes, node if node.type == 'template_declaration' else None, class_context=class_context)
                        if self.is_function_body_long_enough_cpp(target_node):
                            functions.append(func_info)
                        # Don't return here! We might need to traverse children (e.g. lambdas, though typically not nested functions in C++)
                        # Actually, to be safe and avoid complexity, we can stop here for this branch unless we want detailed lambda support.
                        # But wait, C++ functions can't have nested functions (standard), but can have classes.
                        return

                # Handle Classes/Structs
                if node.type in ('class_specifier', 'struct_specifier'):
                    class_info = self._extract_cpp_class_info(node, content, content_bytes)
                    classes.append(class_info)
                    
                    # Traverse children with class context
                    for child in node.children:
                        traverse(child, class_context=True)
                    return

                # Traverse children
                for child in node.children:
                    traverse(child, class_context)

            traverse(tree.root_node)
            
            # Metadata
            file_size = file_path.stat().st_size
            file_hash = hashlib.sha256(content_bytes).hexdigest()
            line_count = len(content.splitlines())
            
            relative_path = str(file_path.relative_to(self.base_directory))
            repository = relative_path.split('/')[0] if '/' in relative_path else "unknown"
            
            complexity_metrics = self.calculate_file_complexity(functions, classes)
            
            return FileInfo(
                file_path=str(file_path),
                relative_path=relative_path,
                repository=repository,
                file_size=file_size,
                line_count=line_count,
                file_hash=file_hash,
                encoding='utf-8',
                imports=[],  # Extraction of includes could be added
                global_variables=[],  # Extraction of globals could be added
                functions=functions,
                classes=classes,
                main_execution_block=None,
                complexity_metrics=complexity_metrics,
                ast_valid=True,
                extraction_timestamp=datetime.now().isoformat()
            )

        except Exception as e:
            print(f"Error analyzing C++ file {file_path}: {e}")
            try:
                 with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                    content = f.read()
            except:
                content = "Could not read content"
            
            self.failed_files.append({
                'file_path': str(file_path),
                'error': str(e),
                'content': content
            })
            return None

    def analyze_c_file(self, file_path: Path) -> Optional[FileInfo]:
        """Analyze a single C file using tree-sitter-c"""
        if not self.c_parser:
             print(f"Skipping C file {file_path}: tree-sitter-c not initialized")
             return None

        try:
             # Read file content
            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                content = f.read()
                content_bytes = content.encode('utf-8')
            
            tree = self.c_parser.parse(content_bytes)
            
            functions = []
            classes = []  # structs
            
            cursor = tree.walk()
            
            def traverse(node):
                # Handle Functions
                if node.type == 'function_definition':
                    func_info = self._extract_cpp_function_info(node, content, content_bytes, class_context=False)
                    if self.is_function_body_long_enough_cpp(node):
                        functions.append(func_info)
                    return

                # Handle Structs / Unions
                if node.type in ('struct_specifier', 'union_specifier'):
                     # Check if it is anonymous and wrapped in typedef
                     # Handled at 'type_definition' level usually, but we can capture named structs here
                     if node.child_by_field_name('name'):
                         class_info = self._extract_c_struct_info(node, content, content_bytes)
                         classes.append(class_info)
                     return

                # Handle Typedef Structs
                if node.type == 'type_definition':
                    # Check if subtype is struct_specifier
                    type_node = node.child_by_field_name('type')
                    declarator = node.child_by_field_name('declarator')
                    if type_node and type_node.type in ('struct_specifier', 'union_specifier'):
                         # It is a typedef struct
                         # We pass the type_definition name as the class name
                        name_str = "unknown"
                        if declarator and declarator.type == 'type_identifier':
                             name_str = content_bytes[declarator.start_byte:declarator.end_byte].decode('utf-8')
                        
                        class_info = self._extract_c_struct_info(type_node, content, content_bytes, name_override=name_str)
                        classes.append(class_info)
                        return  # Should we traverse children? struct body is inside type_node
                
                for child in node.children:
                    traverse(child)

            traverse(tree.root_node)

            # Metadata
            file_size = file_path.stat().st_size
            file_hash = hashlib.sha256(content_bytes).hexdigest()
            line_count = len(content.splitlines())
            
            relative_path = str(file_path.relative_to(self.base_directory))
            repository = relative_path.split('/')[0] if '/' in relative_path else "unknown"
            
            complexity_metrics = self.calculate_file_complexity(functions, classes)
            
            return FileInfo(
                file_path=str(file_path),
                relative_path=relative_path,
                repository=repository,
                file_size=file_size,
                line_count=line_count,
                file_hash=file_hash,
                encoding='utf-8',
                imports=[], 
                global_variables=[], 
                functions=functions,
                classes=classes,
                main_execution_block=None,
                complexity_metrics=complexity_metrics,
                ast_valid=True,
                extraction_timestamp=datetime.now().isoformat()
            )

        except Exception as e:
            print(f"Error analyzing C file {file_path}: {e}")
            try:
                 with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                    content = f.read()
            except:
                content = "Could not read content"
            
            self.failed_files.append({
                'file_path': str(file_path),
                'error': str(e),
                'content': content
            })
            return None

    def _extract_c_struct_info(self, node, content: str, content_bytes: bytes, name_override: str = None) -> ClassInfo:
        start_point = node.start_point
        end_point = node.end_point
        
        name = name_override
        if not name:
            name_node = node.child_by_field_name('name')
            if name_node:
                name = content_bytes[name_node.start_byte:name_node.end_byte].decode('utf-8')
            else:
                name = "anonymous_struct"
            
        docstring = None
        prev = node.prev_sibling
        if prev and prev.type == 'comment':
             docstring = content_bytes[prev.start_byte:prev.end_byte].decode('utf-8')
             
        methods = []  # function pointers
        
        body_node = node.child_by_field_name('body')
        if body_node:
             for child in body_node.children:
                 if child.type == 'field_declaration':
                     # Check for function pointer
                     # field_declaration -> declarator: function_declarator or pointer_declarator wrapping function_declarator
                     declarator = child.child_by_field_name('declarator')
                     if self._is_function_pointer(declarator):
                          # Extract name
                          fp_name = self._extract_function_pointer_name(declarator, content_bytes)
                          if fp_name:
                              methods.append(fp_name)
        
        return ClassInfo(
            name=name,
            line_start=start_point[0] + 1,
            line_end=end_point[0] + 1,
            docstring=docstring,
            base_classes=[],
            methods=methods,
            class_variables=[],
            decorators=[]
        )

    def _is_function_pointer(self, declarator_node) -> bool:
        if not declarator_node: return False
        # recursive check
        curr = declarator_node
        while curr:
             if curr.type == 'function_declarator':
                 return True
             if curr.type == 'parenthesized_declarator':
                 curr = curr.child_by_field_name('declarator')
                 continue
             if curr.type == 'pointer_declarator':
                 curr = curr.child_by_field_name('declarator')
                 continue
             break
        return False

    def _extract_function_pointer_name(self, declarator_node, content_bytes) -> Optional[str]:
         # Drill down to identifier
         curr = declarator_node
         while curr:
             if curr.type == 'identifier' or curr.type == 'field_identifier':
                 return content_bytes[curr.start_byte:curr.end_byte].decode('utf-8')
             if curr.child_by_field_name('declarator'):
                 curr = curr.child_by_field_name('declarator')
             elif curr.child_count > 0:
                  # fallback heuristic
                  for child in curr.children:
                      res = self._extract_function_pointer_name(child, content_bytes)
                      if res: return res
                  break
             else:
                  break
         return None

    def _extract_cpp_function_name(self, node, content_bytes: bytes) -> str:
        """Helper to extract function name from node"""
        declarator = node.child_by_field_name('declarator')
        name = "unknown"
        
        # Drill down declarator to find name
        curr = declarator
        while curr:
            if curr.type == 'function_declarator':
                declarator = curr.child_by_field_name('declarator')
                curr = declarator
            elif curr.type == 'identifier':
                name = content_bytes[curr.start_byte:curr.end_byte].decode('utf-8')
                break
            elif curr.type == 'field_identifier':
                 name = content_bytes[curr.start_byte:curr.end_byte].decode('utf-8')
                 break
            elif curr.type == 'qualified_identifier':
                 name = content_bytes[curr.start_byte:curr.end_byte].decode('utf-8')
                 break
            elif curr.type == 'destructor_name':
                 name = content_bytes[curr.start_byte:curr.end_byte].decode('utf-8')
                 break
            elif curr.type == 'reference_declarator' or curr.type == 'pointer_declarator':
                 curr = curr.child_by_field_name('declarator')
            else:
                 if curr.child_count > 0:
                     found = False
                     for child in curr.children:
                         if child.type == 'identifier':
                             name = content_bytes[child.start_byte:child.end_byte].decode('utf-8')
                             found = True
                             break
                     if found: break
                 break
        return name

    def _extract_cpp_function_info(self, node, content: str, content_bytes: bytes, template_node=None, class_context: bool = False) -> FunctionInfo:
        # Get basic info
        start_byte = node.start_byte
        end_byte = node.end_byte
        start_point = node.start_point  # (row, col)
        end_point = node.end_point
        
        # Use template node for full range if it exists
        if template_node:
            start_byte = template_node.start_byte
            end_byte = template_node.end_byte
            start_point = template_node.start_point
            end_point = template_node.end_point
        
        body_node = node.child_by_field_name('body')
        body = content_bytes[start_byte:end_byte].decode('utf-8')
        
        # Name
        name = self._extract_cpp_function_name(node, content_bytes)
        
        declarator = node.child_by_field_name('declarator')
        parameters_node = None
        
        # Extract parameters node (similar to name extraction path)
        curr = declarator

        if not parameters_node and declarator and declarator.type == 'function_declarator':
             parameters_node = declarator.child_by_field_name('parameters')

        # Signature (without body)
        signature_end = body_node.start_byte if body_node else end_byte
        signature = content_bytes[start_byte:signature_end].decode('utf-8').strip()

        # Docstring (comments before)
        docstring = None
        # Look at previous sibling of the start node
        prev = (template_node or node).prev_sibling
        if prev and prev.type == 'comment':
             docstring = content_bytes[prev.start_byte:prev.end_byte].decode('utf-8')
        
        # Parameters
        parameters = []
        if parameters_node:
            for i, param in enumerate(parameters_node.children):
                if param.type in ('parameter_declaration', 'optional_parameter_declaration'):
                    p_name = "unknown"
                    p_type = "unknown"
                    
                    # Extract type and name
                    p_type_node = param.child_by_field_name('type')
                    p_decl_node = param.child_by_field_name('declarator')
                    
                    if p_type_node:
                        p_type = content_bytes[p_type_node.start_byte:p_type_node.end_byte].decode('utf-8')
                    
                    if p_decl_node:
                        p_name = content_bytes[p_decl_node.start_byte:p_decl_node.end_byte].decode('utf-8')
                    
                    parameters.append({
                        'name': p_name,
                        'type_annotation': p_type,
                        'position': i,
                        'kind': 'positional',
                        'default': None
                    })

        # Return type
        return_type = None
        type_node = node.child_by_field_name('type')
        if type_node:
             return_type = content_bytes[type_node.start_byte:type_node.end_byte].decode('utf-8')

        # Properties
        is_static = False
        # Check modifiers inside traversal or source text?
        # Tree sitter structure for 'storage_class_specifier' usually sibling or child
        # Actually in C++, static is part of storage_class_specifier in declaration
        # For simplicity, check raw text of signature parts?
        # Or check children of function_definition (it can have storage_class_specifier)
        for child in node.children:
            if child.type == 'storage_class_specifier' and 'static' in content_bytes[child.start_byte:child.end_byte].decode('utf-8'):
                is_static = True
        
        return FunctionInfo(
            name=name,
            signature=signature,
            body=body,
            docstring=docstring,
            line_start=start_point[0] + 1,
            line_end=end_point[0] + 1,
            column_offset=start_point[1],
            parameters=parameters,
            return_annotation=return_type,
            decorators=[],  # decorators like [[nodiscard]] could be extracted
            is_async=False,  # C++ coroutines exist but simple check for now
            is_method=class_context,
            is_static_method=is_static,
            is_class_method=False,
            complexity_score=self._calculate_cpp_complexity(node),
            calls_made=self._extract_cpp_calls(node, content_bytes),
            variables_used=[],
            control_structures=self._extract_cpp_control_structures(node),
            imports_used=[]
        )

    def _extract_cpp_class_info(self, node, content: str, content_bytes: bytes) -> ClassInfo:
        start_point = node.start_point
        end_point = node.end_point
        
        name_node = node.child_by_field_name('name')
        name = "anonymous"
        if name_node:
            name = content_bytes[name_node.start_byte:name_node.end_byte].decode('utf-8')
            
        docstring = None
        prev = node.prev_sibling
        if prev and prev.type == 'comment':
             docstring = content_bytes[prev.start_byte:prev.end_byte].decode('utf-8')
             
        # Base classes
        base_classes = []
        bases_node = node.child_by_field_name('base_specifiers')  # Does TS use this?
        # Check actual structure if needed, but for now empty list or basic attempt
        
        methods = []
        body_node = node.child_by_field_name('body')
        if body_node:
            for child in body_node.children:
                target_child = child
                if child.type == 'function_definition' or child.type == 'template_declaration':
                     if child.type == 'template_declaration':
                         for c in child.children:
                             if c.type == 'function_definition':
                                 target_child = c
                                 break
                     
                     if target_child.type == 'function_definition':
                         method_name = self._extract_cpp_function_name(target_child, content_bytes)
                         methods.append(method_name)
        
        return ClassInfo(
            name=name,
            line_start=start_point[0] + 1,
            line_end=end_point[0] + 1,
            docstring=docstring,
            base_classes=base_classes,
            methods=methods,
            class_variables=[],
            decorators=[]
        )

    def is_function_body_long_enough_cpp(self, node) -> bool:
        start_line = node.start_point[0]
        end_line = node.end_point[0]
        return (end_line - start_line + 1) >= self.min_lines

    def _calculate_cpp_complexity(self, node) -> int:
        complexity = 1
        cursor = node.walk()
        # Traverse and count branching nodes
        # 'if_statement', 'for_statement', 'while_statement', 'case_statement', 'catch_clause', 'conditional_expression'
        while True:
            if cursor.node.type in ('if_statement', 'for_statement', 'while_statement', 'case_statement', 'catch_clause', 'conditional_expression', 'binary_expression'):
                # Binary expression check for && and ||
                if cursor.node.type == 'binary_expression':
                     # Need to check operator
                     op_node = cursor.node.child_by_field_name('operator')
                     if op_node:
                         # Accessing text via parser not easy without content? 
                         # Actually we pass node, we need content to check operator? 
                         # Or check children count/types.
                         # Pass on binary for now or be more specific if possible.
                         pass
                else:
                    complexity += 1
            
            if cursor.goto_first_child():
                continue
            if cursor.goto_next_sibling():
                continue
            while cursor.goto_parent():
                if cursor.goto_next_sibling():
                    break
            else:
                break
        return complexity

    def _extract_cpp_calls(self, node, content_bytes) -> List[str]:
        calls = set()
        cursor = node.walk()
        while True:
            if cursor.node.type == 'call_expression':
                func_node = cursor.node.child_by_field_name('function')
                if func_node:
                    calls.add(content_bytes[func_node.start_byte:func_node.end_byte].decode('utf-8'))
            
            if cursor.goto_first_child():
                continue
            if cursor.goto_next_sibling():
                continue
            while cursor.goto_parent():
                if cursor.goto_next_sibling():
                    break
            else:
                break
        return list(calls)

    def _extract_cpp_control_structures(self, node) -> List[str]:
        structures = set()
        cursor = node.walk()
        while True:
            t = cursor.node.type
            if t == 'if_statement': structures.add('if')
            elif t == 'while_statement': structures.add('while')
            elif t == 'for_statement': structures.add('for')
            elif t == 'try_statement': structures.add('try')
            
            if cursor.goto_first_child():
                continue
            if cursor.goto_next_sibling():
                continue
            while cursor.goto_parent():
                if cursor.goto_next_sibling():
                    break
            else:
                break
        return list(structures)

    def analyze_file(self, file_path: Path) -> Optional[FileInfo]:
        """Analyze a file, dispatching to the correct analyzer based on extension"""
        if file_path.suffix in self.python_extensions:
            return self.analyze_python_file(file_path)
        elif file_path.suffix in self.ts_extensions:
            return self.analyze_typescript_file(file_path)
        elif file_path.suffix in self.c_extensions:
            return self.analyze_c_file(file_path)
        elif file_path.suffix in self.cpp_extensions:
            return self.analyze_cpp_file(file_path)
        elif file_path.suffix == '.h':
            # Heuristic for .h files
            if self._detect_header_language(file_path) == 'c':
                 return self.analyze_c_file(file_path)
            else:
                 return self.analyze_cpp_file(file_path)
        else:
            print(f"Unsupported file extension: {file_path.suffix}")
            return None

    def _detect_header_language(self, file_path: Path) -> str:
        """Detect if header is C or C++"""
        try:
             with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                 content = f.read()
             
             # User Rule: "if NO class keyword AND has extern "C" ... force C parser"
             # Also simple "class" check for C++
             
             if 'class ' in content or 'template' in content or 'public:' in content:
                 return 'cpp'
             
             # Check for extern "C" or C macros if no class
             if 'extern "C"' in content:
                 return 'c'  # As per specific user instruction to use C parser?
                 # Actually user said "no class keyword AND contains extern "C" -> force C parser"
                 # Wait, extern "C" is for C++ compiler reading C header.
                 # So if it has extern "C" but no class, it is likely a C header compatible with C++.
                 # Parsing it as C is correct/safe.
             
             # Default to C++ as superset if ambiguous? Or C if simple?
             # Implementation plan said default to C++ unless obvious C.
             return 'cpp'
        except:
             return 'cpp'

    def analyze_typescript_file(self, file_path: Path) -> Optional[FileInfo]:
        """Analyze a single TypeScript file using the Node.js extractor"""
        try:
            # Run the Node.js extractor script
            result = subprocess.run(
                ["node", str(self.ts_extractor_script), str(file_path)],
                capture_output=True,
                text=True,
                check=False
            )
            
            if result.returncode != 0:
                print(f"Error extracting TS info from {file_path}: {result.stderr}")
                try:
                    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                        content = f.read()
                except:
                    content = "Could not read content"
                    
                self.failed_files.append({
                    'file_path': str(file_path),
                    'error': result.stderr,
                    'content': content
                })
                return None
            
            data = json.loads(result.stdout)
            
            # Map JSON data to objects
            functions = []
            for f in data.get('functions', []):
                # Calculate complexity score locally if not provided or just trust the script
                # The script provides it
                
                # Check min lines
                if (f['line_end'] - f['line_start'] + 1) >= self.min_lines:
                    functions.append(FunctionInfo(**f))
            
            classes = []
            for c in data.get('classes', []):
                classes.append(ClassInfo(**c))
                
            imports = data.get('imports', [])
            
            # Metadata
            file_size = file_path.stat().st_size
            # Read file content for hash and line count
            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                content = f.read()
                file_hash = hashlib.sha256(content.encode('utf-8')).hexdigest()
                line_count = len(content.splitlines())
                
            relative_path = str(file_path.relative_to(self.base_directory))
            repository = relative_path.split('/')[0] if '/' in relative_path else "unknown"
            
            # Helper for complexity metrics
            complexity_metrics = self.calculate_file_complexity(functions, classes)
            
            return FileInfo(
                file_path=str(file_path),
                relative_path=relative_path,
                repository=repository,
                file_size=file_size,
                line_count=line_count,
                file_hash=file_hash,
                encoding='utf-8',
                imports=imports,
                global_variables=[],  # Not fully extracted yet by JS script
                functions=functions,
                classes=classes,
                main_execution_block=None,
                complexity_metrics=complexity_metrics,
                ast_valid=True,  # Assumed valid if parsing succeeded
                extraction_timestamp=datetime.now().isoformat()
            )
            
        except Exception as e:
            print(f"Error analyzing TS file {file_path}: {e}")
            try:
                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                    content = f.read()
            except:
                content = "Could not read content"
                
            self.failed_files.append({
                'file_path': str(file_path),
                'error': str(e),
                'content': content
            })
            return None

    def find_typescript_files(self) -> List[Path]:
        """Find all TypeScript files in the base directory"""
        ts_files = []
        
        try:
            for root, dirs, files in os.walk(self.base_directory):
                # Skip excluded directories
                dirs[:] = [d for d in dirs if d not in self.excluded_dirs and not d.startswith('test')]
                
                for file in files:
                    if (any(file.endswith(ext) for ext in self.ts_extensions) and 
                        file not in self.excluded_files and 
                        not file.startswith('test')):
                        file_path = Path(root) / file
                         # Skip very small files
                        if file_path.stat().st_size > 50:
                            relative_path = file_path.relative_to(self.base_directory)
                            if not any(part.startswith('test') for part in relative_path.parts[:-1]):
                                ts_files.append(file_path)
        except Exception as e:
            print(f"Error finding TS files: {e}")
        
        return ts_files
    
    def find_cpp_files(self) -> List[Path]:
        """Find all C++ files in the base directory"""
        cpp_files = []
        
        try:
            for root, dirs, files in os.walk(self.base_directory):
                # Skip excluded directories
                dirs[:] = [d for d in dirs if d not in self.excluded_dirs and not d.startswith('test')]
                
                for file in files:
                    if file in self.excluded_files or file.startswith('test'):
                        continue
                        
                    is_cpp = any(file.endswith(ext) for ext in self.cpp_extensions)
                    is_h = file.endswith('.h')
                    
                    if (is_cpp or is_h):
                        file_path = Path(root) / file
                         # Skip very small files
                        if file_path.stat().st_size > 50:
                            relative_path = file_path.relative_to(self.base_directory)
                            if not any(part.startswith('test') for part in relative_path.parts[:-1]):
                                cpp_files.append(file_path)

        except Exception as e:
            print(f"Error finding C++ files: {e}")
        
        return cpp_files
    
    def find_c_files(self) -> List[Path]:
        """Find all C files in the base directory"""
        c_files = []
        try:
            for root, dirs, files in os.walk(self.base_directory):
                dirs[:] = [d for d in dirs if d not in self.excluded_dirs and not d.startswith('test')]
                for file in files:
                    if (any(file.endswith(ext) for ext in self.c_extensions) and 
                        file not in self.excluded_files and not file.startswith('test')):
                        file_path = Path(root) / file
                        if file_path.stat().st_size > 50:
                            relative_path = file_path.relative_to(self.base_directory)
                            if not any(part.startswith('test') for part in relative_path.parts[:-1]):
                                c_files.append(file_path)
        except Exception as e:
            print(f"Error finding C files: {e}")
        return c_files
    
    def find_python_files(self) -> List[Path]:
        """Find all Python files in the base directory"""
        python_files = []
        
        try:
            for root, dirs, files in os.walk(self.base_directory):
                # Skip excluded directories and test directories
                dirs[:] = [d for d in dirs if d not in self.excluded_dirs and not d.startswith('test')]
                
                # Skip .venv/lib directories
                if '.venv/lib' in root or '.venv\\lib' in root:
                    continue
                
                for file in files:
                    # Skip test files and other excluded files
                    if (file.endswith('.py') and 
                        file not in self.excluded_files and 
                        not file.startswith('test')):
                        file_path = Path(root) / file
                        # Skip very small files (likely not substantial code)
                        if file_path.stat().st_size > 50:
                            # Skip if any parent directory starts with 'test'
                            relative_path = file_path.relative_to(self.base_directory)
                            if not any(part.startswith('test') for part in relative_path.parts[:-1]):
                                python_files.append(file_path)
        except Exception as e:
            print(f"Error finding Python files: {e}")
        
        return python_files
    
    def extract_all_functions(self, max_files: Optional[int] = None, 
                            output_file: str = "extracted_functions.json",
                            target_lang: Optional[str] = None) -> Dict[str, Any]:
        """Extract function information from files, optionally filtered by language"""
        
        python_files = []
        ts_files = []
        js_files = []
        cpp_files = []
        c_files = []
        
        lang = target_lang.lower() if target_lang else None
        
        if not lang or lang == 'python':
            python_files = self.find_python_files()
            
        if not lang or lang in ('ts', 'typescript', 'js', 'javascript'):
            raw_ts_js_files = self.find_typescript_files()
            
            # Split into TS and JS files based on extension
            ts_suffixes = {'.ts', '.tsx'}
            js_suffixes = {'.js', '.jsx'}
            
            real_ts_files = [f for f in raw_ts_js_files if f.suffix in ts_suffixes]
            real_js_files = [f for f in raw_ts_js_files if f.suffix in js_suffixes]
            
            # Filter based on specific lang selection if provided
            if lang in ('ts', 'typescript'):
                ts_files = real_ts_files
            elif lang in ('js', 'javascript'):
                js_files = real_js_files
            else:
                # Both if generic or None
                ts_files = real_ts_files
                js_files = real_js_files
            
        if not lang or lang == 'cpp':
            cpp_files = self.find_cpp_files()
        
        if not lang or lang == 'c':
            c_files = self.find_c_files()
        
        all_files = python_files + ts_files + js_files + cpp_files + c_files
        
        if max_files:
            all_files = all_files[:max_files]
        
        print(f"Extracting function information from {len(python_files)} Python, {len(ts_files)} TypeScript, {len(js_files)} JavaScript, {len(cpp_files)} C++, and {len(c_files)} C files...")
        print(f"Total files to process: {len(all_files)}")
        
        extracted_files = []
        total_functions = 0
        total_classes = 0
        python_success_count = 0
        ts_success_count = 0
        js_success_count = 0
        cpp_success_count = 0
        c_success_count = 0
        
        for file_path in tqdm(all_files, desc="Extracting functions"):
            file_info = self.analyze_file(file_path)
                
            if file_info:
                extracted_files.append(file_info)
                total_functions += len(file_info.functions)
                total_classes += len(file_info.classes)
                
                if file_path.suffix in self.python_extensions:
                    python_success_count += 1
                elif file_path.suffix in {'.ts', '.tsx'}:
                    ts_success_count += 1
                elif file_path.suffix in {'.js', '.jsx'}:
                    js_success_count += 1
                elif file_path.suffix in self.cpp_extensions or file_path.suffix == '.h':
                    # Check extraction result to see which one was used? 
                    # Actually we can just track extensions
                    # If it was .h, it could be reckoned as cpp here for stats, or we split it in metadata
                    cpp_success_count += 1
                elif file_path.suffix in self.c_extensions:
                    c_success_count += 1
        
        # Create comprehensive output
        extraction_result = {
            'extraction_metadata': {
                'timestamp': datetime.now().isoformat(),
                'base_directory': str(self.base_directory),
                'total_files_analyzed': len(extracted_files),
                'total_functions_extracted': total_functions,
                'total_classes_extracted': total_classes,
                'python_files_found': len(python_files),
                'ts_files_found': len(ts_files),
                'js_files_found': len(js_files),
                'cpp_files_found': len(cpp_files),
                'c_files_found': len(c_files),
                'extraction_successful': len(extracted_files) / len(all_files) * 100 if all_files else 0,
                'python_success_rate': python_success_count / len(python_files) * 100 if python_files else 0,
                'ts_success_rate': ts_success_count / len(ts_files) * 100 if ts_files else 0,
                'js_success_rate': js_success_count / len(js_files) * 100 if js_files else 0,
                'cpp_success_rate': cpp_success_count / len(cpp_files) * 100 if cpp_files else 0,
                'c_success_rate': c_success_count / len(c_files) * 100 if c_files else 0,
                'python_files_analyzed': python_success_count,
                'ts_files_analyzed': ts_success_count,
                'js_files_analyzed': js_success_count,
                'cpp_files_analyzed': cpp_success_count,
                'c_files_analyzed': c_success_count
            },
            'files': [asdict(file_info) for file_info in extracted_files]
        }
        
        # Save to JSON file
        try:
            with open(output_file, 'w', encoding='utf-8') as f:
                json.dump(extraction_result, f, indent=2, ensure_ascii=False)
            print(f"✅ Function information saved to {output_file}")
        except Exception as e:
            print(f"❌ Error saving results: {e}")
        
        # Save failed files
        if self.failed_files:
            date_str = datetime.now().strftime('%Y_%m_%d')
            failed_output_file = f"failed_{date_str}_extraction.json"
            try:
                with open(failed_output_file, 'w', encoding='utf-8') as f:
                    json.dump(self.failed_files, f, indent=2, ensure_ascii=False)
                print(f"⚠️  Saved {len(self.failed_files)} failed files to {failed_output_file}")
            except Exception as e:
                print(f"❌ Error saving failed files log: {e}")
        
        # Print summary statistics
        self.print_extraction_summary(extraction_result)
        
        return extraction_result
    
    def print_extraction_summary(self, result: Dict[str, Any]):
        """Print comprehensive extraction summary"""
        metadata = result['extraction_metadata']
        files = result['files']
        
        print("\n" + "="*80)
        print("📊 FUNCTION EXTRACTION SUMMARY")
        print("="*80)
        
        print(f"📁 Files analyzed: {metadata['total_files_analyzed']}")
        print(f"🔧 Functions extracted: {metadata['total_functions_extracted']}")
        print(f"🏛️  Classes extracted: {metadata['total_classes_extracted']}")
        print(f"✅ Overall Success rate: {metadata['extraction_successful']:.1f}%")
        print(f"  🐍 Python Success rate: {metadata.get('python_success_rate', 0):.1f}% ({metadata.get('python_files_analyzed', 0)}/{metadata.get('python_files_found', 0)})")
        print(f"  📘 TypeScript Success rate: {metadata.get('ts_success_rate', 0):.1f}% ({metadata.get('ts_files_analyzed', 0)}/{metadata.get('ts_files_found', 0)})")
        print(f"  📜 JavaScript Success rate: {metadata.get('js_success_rate', 0):.1f}% ({metadata.get('js_files_analyzed', 0)}/{metadata.get('js_files_found', 0)})")
        print(f"  ➕ C++ Success rate: {metadata.get('cpp_success_rate', 0):.1f}% ({metadata.get('cpp_files_analyzed', 0)}/{metadata.get('cpp_files_found', 0)})")
        print(f"  🇨 C Success rate: {metadata.get('c_success_rate', 0):.1f}% ({metadata.get('c_files_analyzed', 0)}/{metadata.get('c_files_found', 0)})")


        
        if files:
            # Function statistics
            all_functions = []
            for file_info in files:
                all_functions.extend(file_info['functions'])
            
            if all_functions:
                avg_complexity = sum(f['complexity_score'] for f in all_functions) / len(all_functions)
                max_complexity = max(f['complexity_score'] for f in all_functions)
                
                print(f"\n🧮 COMPLEXITY ANALYSIS:")
                print(f"Average function complexity: {avg_complexity:.1f}")
                print(f"Maximum function complexity: {max_complexity}")
            
            # Repository breakdown
            repo_stats = {}
            for file_info in files:
                repo = file_info['repository']
                if repo not in repo_stats:
                    repo_stats[repo] = {'files': 0, 'functions': 0}
                repo_stats[repo]['files'] += 1
                repo_stats[repo]['functions'] += len(file_info['functions'])
            
            print(f"\n🎮 REPOSITORY BREAKDOWN:")
            for repo, stats in sorted(repo_stats.items()):
                print(f"  {repo}: {stats['files']} files, {stats['functions']} functions")
            
            # Function name analysis
            function_names = [f['name'] for file_info in files for f in file_info['functions']]
            common_names = {}
            for name in function_names:
                common_names[name] = common_names.get(name, 0) + 1
            
            print(f"\n🏷️  MOST COMMON FUNCTION NAMES:")
            for name, count in sorted(common_names.items(), key=lambda x: x[1], reverse=True)[:10]:
                print(f"  {name}: {count} occurrences")
        
        print("="*80)


def main():
    """Main function"""
    parser = argparse.ArgumentParser(description="Extract function information from Python game repositories")
    parser.add_argument("--base-dir", default="repos_GAME_python_demo",
                       help="Base directory containing game repositories")
    parser.add_argument("--max-files", type=int,
                       help="Maximum number of files to process")
    parser.add_argument("--output-file", default="Jsons/extracted_functions.json",
                       help="Output JSON file for extracted information")
    parser.add_argument("--summary-only", action="store_true",
                       help="Only print summary statistics without saving full data")
    parser.add_argument("--min-lines", type=int, default=28,
                       help="Minimum number of lines for a function to be considered")
    parser.add_argument("--lang", type=str, choices=['python', 'cpp', 'c', 'typescript', 'ts', 'javascript', 'js'],
                       help="Specific language to extract (python, cpp, c, typescript)")
    
    args = parser.parse_args()
    
    # Create extractor
    extractor = FunctionExtractor(base_directory=args.base_dir, min_lines=args.min_lines)
    
    # Extract function information
    if args.summary_only:
        # Quick analysis without full data extraction
        python_files = extractor.find_python_files()
        if args.max_files:
            python_files = python_files[:args.max_files]
        
        print(f"Found {len(python_files)} Python files in {args.base_dir}")
        
        total_functions = 0
        for file_path in tqdm(python_files[:10], desc="Quick analysis"):  # Sample first 10
            file_info = extractor.analyze_python_file(file_path)
            if file_info:
                total_functions += len(file_info.functions)
        
        print(f"Estimated total functions: ~{total_functions * len(python_files) // min(10, len(python_files))}")
    else:
        result = extractor.extract_all_functions(
            max_files=args.max_files,
            output_file=args.output_file,
            target_lang=args.lang
        )
        
        print(f"\n✅ Function extraction complete!")
        print(f"📄 Results saved to: {args.output_file}")

if __name__ == "__main__":
    main()