@mc1global/opencode-jarvis 0.13.1 → 0.14.0

package/scripts/parsers/language_parsers.py

@@ -1,966 +0,0 @@
-#!/usr/bin/env python3
-"""
-Multi-Language Code Parsers using Tree-Sitter.
-
-Provides fast, accurate parsing for multiple programming languages:
-- Kotlin, Java, Swift (mobile development)
-- JavaScript, TypeScript (web development)
-- Go, Rust, C, C++ (systems programming)
-- Python (fallback to AST when tree-sitter unavailable)
-
-Zero API cost - all parsing done locally.
-"""
-
-import re
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple
-
-# Tree-sitter imports (optional, falls back to regex if unavailable)
-try:
-    import tree_sitter_languages
-    TREE_SITTER_AVAILABLE = True
-except ImportError:
-    TREE_SITTER_AVAILABLE = False
-    print("Warning: tree-sitter-languages not installed. Using regex fallback.", file=__import__('sys').stderr)
-
-
-@dataclass
-class CodeBlock:
-    """Represents a code block (function, class, method)."""
-    name: str
-    block_type: str  # "function", "method", "class", "interface"
-    line_start: int
-    line_end: int
-    signature: Optional[str] = None
-    parent_class: Optional[str] = None
-
-
-# =============================================================================
-# Language Detection
-# =============================================================================
-
-EXTENSION_TO_LANGUAGE = {
-    # Python
-    '.py': 'python',
-    '.pyi': 'python',
-
-    # Kotlin/Java
-    '.kt': 'kotlin',
-    '.kts': 'kotlin',
-    '.java': 'java',
-
-    # Swift
-    '.swift': 'swift',
-
-    # JavaScript/TypeScript
-    '.js': 'javascript',
-    '.mjs': 'javascript',
-    '.cjs': 'javascript',
-    '.jsx': 'javascript',
-    '.ts': 'typescript',
-    '.tsx': 'typescript',
-
-    # Go
-    '.go': 'go',
-
-    # Rust
-    '.rs': 'rust',
-
-    # C/C++
-    '.c': 'c',
-    '.h': 'c',
-    '.cpp': 'cpp',
-    '.cc': 'cpp',
-    '.cxx': 'cpp',
-    '.hpp': 'cpp',
-    '.hxx': 'cpp',
-
-    # Shell
-    '.sh': 'bash',
-    '.bash': 'bash',
-
-    # Ruby
-    '.rb': 'ruby',
-
-    # PHP
-    '.php': 'php',
-
-    # C#
-    '.cs': 'c_sharp',
-}
-
-
-def detect_language(file_path: Path) -> str:
-    """Detect programming language from file extension."""
-    suffix = file_path.suffix.lower()
-    return EXTENSION_TO_LANGUAGE.get(suffix, 'unknown')
-
-
-# =============================================================================
-# Tree-Sitter Parser
-# =============================================================================
-
-class TreeSitterParser:
-    """Parser using tree-sitter for accurate multi-language support."""
-
-    # Query patterns for different languages
-    FUNCTION_QUERIES = {
-        'kotlin': """
-            (function_declaration name: (simple_identifier) @name) @function
-            (class_declaration
-                name: (type_identifier) @class_name
-                body: (class_body
-                    (function_declaration name: (simple_identifier) @method_name) @method))
-        """,
-        'java': """
-            (method_declaration name: (identifier) @name) @method
-            (constructor_declaration name: (identifier) @name) @constructor
-        """,
-        'javascript': """
-            (function_declaration name: (identifier) @name) @function
-            (method_definition name: (property_identifier) @name) @method
-            (arrow_function) @arrow
-            (function_expression) @func_expr
-        """,
-        'typescript': """
-            (function_declaration name: (identifier) @name) @function
-            (method_definition name: (property_identifier) @name) @method
-            (arrow_function) @arrow
-        """,
-        'go': """
-            (function_declaration name: (identifier) @name) @function
-            (method_declaration name: (field_identifier) @name) @method
-        """,
-        'swift': """
-            (function_declaration name: (simple_identifier) @name) @function
-            (class_declaration name: (type_identifier) @class_name) @class
-        """,
-        'rust': """
-            (function_item name: (identifier) @name) @function
-            (impl_item) @impl
-        """,
-    }
-
-    CLASS_QUERIES = {
-        'kotlin': """
-            (class_declaration name: (type_identifier) @name) @class
-            (object_declaration name: (type_identifier) @name) @object
-            (interface_declaration name: (type_identifier) @name) @interface
-        """,
-        'java': """
-            (class_declaration name: (identifier) @name) @class
-            (interface_declaration name: (identifier) @name) @interface
-            (enum_declaration name: (identifier) @name) @enum
-        """,
-        'javascript': """
-            (class_declaration name: (identifier) @name) @class
-        """,
-        'typescript': """
-            (class_declaration name: (type_identifier) @name) @class
-            (interface_declaration name: (type_identifier) @name) @interface
-        """,
-        'go': """
-            (type_declaration (type_spec name: (type_identifier) @name)) @type
-        """,
-        'swift': """
-            (class_declaration name: (type_identifier) @name) @class
-            (struct_declaration name: (type_identifier) @name) @struct
-            (protocol_declaration name: (type_identifier) @name) @protocol
-        """,
-        'rust': """
-            (struct_item name: (type_identifier) @name) @struct
-            (impl_item type: (type_identifier) @name) @impl
-            (trait_item name: (type_identifier) @name) @trait
-        """,
-    }
-
-    def __init__(self):
-        if not TREE_SITTER_AVAILABLE:
-            raise ImportError("tree-sitter-languages not available")
-
-    def _get_parser(self, language: str):
-        """Get tree-sitter parser for language."""
-        # Map our language names to tree-sitter names
-        ts_language_map = {
-            'javascript': 'javascript',
-            'typescript': 'typescript',
-            'kotlin': 'kotlin',
-            'java': 'java',
-            'go': 'go',
-            'swift': 'swift',
-            'rust': 'rust',
-            'c': 'c',
-            'cpp': 'cpp',
-            'c_sharp': 'c_sharp',
-            'ruby': 'ruby',
-            'php': 'php',
-            'bash': 'bash',
-        }
-
-        ts_lang = ts_language_map.get(language)
-        if not ts_lang:
-            return None
-
-        try:
-            return tree_sitter_languages.get_parser(ts_lang)
-        except Exception:
-            return None
-
-    def list_functions(self, file_path: Path, language: str) -> List[CodeBlock]:
-        """List all functions/methods using tree-sitter."""
-        parser = self._get_parser(language)
-        if not parser:
-            return []
-
-        with open(file_path, 'r', encoding='utf-8') as f:
-            content = f.read()
-            lines = content.split('\n')
-
-        tree = parser.parse(bytes(content, 'utf-8'))
-        root = tree.root_node
-
-        functions = []
-        self._extract_functions_recursive(root, lines, functions, language)
-
-        return functions
-
-    def _extract_functions_recursive(
-        self,
-        node,
-        lines: List[str],
-        functions: List[CodeBlock],
-        language: str,
-        parent_class: Optional[str] = None
-    ):
-        """Recursively extract functions from AST."""
-        # Function/method node types by language
-        function_types = {
-            'kotlin': ['function_declaration', 'anonymous_function'],
-            'java': ['method_declaration', 'constructor_declaration'],
-            'javascript': ['function_declaration', 'method_definition', 'arrow_function', 'function_expression'],
-            'typescript': ['function_declaration', 'method_definition', 'arrow_function', 'function_signature'],
-            'go': ['function_declaration', 'method_declaration'],
-            'swift': ['function_declaration', 'init_declaration'],
-            'rust': ['function_item'],
-            'c': ['function_definition'],
-            'cpp': ['function_definition'],
-        }
-
-        class_types = {
-            'kotlin': ['class_declaration', 'object_declaration'],
-            'java': ['class_declaration', 'interface_declaration'],
-            'javascript': ['class_declaration'],
-            'typescript': ['class_declaration', 'interface_declaration'],
-            'go': ['type_declaration'],
-            'swift': ['class_declaration', 'struct_declaration'],
-            'rust': ['struct_item', 'impl_item'],
-        }
-
-        func_types = function_types.get(language, [])
-        cls_types = class_types.get(language, [])
-
-        # Check if this node is a class
-        current_class = parent_class
-        if node.type in cls_types:
-            # Extract class name
-            for child in node.children:
-                if child.type in ['type_identifier', 'identifier', 'simple_identifier']:
-                    current_class = child.text.decode('utf-8')
-                    break
-
-        # Check if this node is a function
-        if node.type in func_types:
-            name = None
-
-            # First check direct children for name (function_declaration)
-            for child in node.children:
-                if child.type in ['identifier', 'simple_identifier', 'field_identifier', 'property_identifier']:
-                    name = child.text.decode('utf-8')
-                    break
-
-            # For arrow functions and function expressions, name comes from parent
-            if not name and node.type in ['arrow_function', 'function_expression']:
-                parent = node.parent
-                if parent and parent.type == 'variable_declarator':
-                    for child in parent.children:
-                        if child.type == 'identifier':
-                            name = child.text.decode('utf-8')
-                            break
-                elif parent and parent.type == 'pair':
-                    for child in parent.children:
-                        if child.type in ['property_identifier', 'string']:
-                            name = child.text.decode('utf-8').strip('"\'')
-                            break
-
-            if name:
-                # Filter out control flow keywords that might be misidentified
-                control_keywords = {'if', 'else', 'for', 'while', 'switch', 'case', 'try', 'catch', 'finally', 'do'}
-                if name.lower() in control_keywords:
-                    # Still recurse into children
-                    for child in node.children:
-                        self._extract_functions_recursive(child, lines, functions, language, current_class)
-                    return
-
-                # Calculate line numbers (tree-sitter is 0-indexed)
-                line_start = node.start_point[0] + 1
-                line_end = node.end_point[0] + 1
-
-                # Determine if method or function
-                block_type = 'method' if current_class else 'function'
-
-                # Extract signature (first line)
-                signature = lines[line_start - 1].strip() if line_start <= len(lines) else None
-
-                functions.append(CodeBlock(
-                    name=name,
-                    block_type=block_type,
-                    line_start=line_start,
-                    line_end=line_end,
-                    signature=signature,
-                    parent_class=current_class
-                ))
-
-        # Recurse into children
-        for child in node.children:
-            self._extract_functions_recursive(child, lines, functions, language, current_class)
-
-    def list_classes(self, file_path: Path, language: str) -> List[CodeBlock]:
-        """List all classes/interfaces using tree-sitter."""
-        parser = self._get_parser(language)
-        if not parser:
-            return []
-
-        with open(file_path, 'r', encoding='utf-8') as f:
-            content = f.read()
-            lines = content.split('\n')
-
-        tree = parser.parse(bytes(content, 'utf-8'))
-        root = tree.root_node
-
-        classes = []
-        self._extract_classes_recursive(root, lines, classes, language)
-
-        return classes
-
-    def _extract_classes_recursive(
-        self,
-        node,
-        lines: List[str],
-        classes: List[CodeBlock],
-        language: str
-    ):
-        """Recursively extract classes from AST."""
-        class_types = {
-            'kotlin': ['class_declaration', 'object_declaration', 'interface_declaration'],
-            'java': ['class_declaration', 'interface_declaration', 'enum_declaration'],
-            'javascript': ['class_declaration'],
-            'typescript': ['class_declaration', 'interface_declaration'],
-            'go': ['type_declaration'],
-            'swift': ['class_declaration', 'struct_declaration', 'protocol_declaration', 'enum_declaration'],
-            'rust': ['struct_item', 'trait_item', 'enum_item'],
-            'c_sharp': ['class_declaration', 'interface_declaration', 'struct_declaration'],
-        }
-
-        cls_types = class_types.get(language, [])
-
-        if node.type in cls_types:
-            name = None
-            for child in node.children:
-                if child.type in ['type_identifier', 'identifier', 'simple_identifier']:
-                    name = child.text.decode('utf-8')
-                    break
-
-            if name:
-                line_start = node.start_point[0] + 1
-                line_end = node.end_point[0] + 1
-
-                # Determine block type
-                block_type = 'class'
-                if 'interface' in node.type:
-                    block_type = 'interface'
-                elif 'struct' in node.type:
-                    block_type = 'struct'
-                elif 'object' in node.type:
-                    block_type = 'object'
-                elif 'enum' in node.type:
-                    block_type = 'enum'
-                elif 'trait' in node.type or 'protocol' in node.type:
-                    block_type = 'protocol'
-
-                signature = lines[line_start - 1].strip() if line_start <= len(lines) else None
-
-                classes.append(CodeBlock(
-                    name=name,
-                    block_type=block_type,
-                    line_start=line_start,
-                    line_end=line_end,
-                    signature=signature
-                ))
-
-        for child in node.children:
-            self._extract_classes_recursive(child, lines, classes, language)
-
-    def get_block(self, file_path: Path, block_name: str, language: str) -> Optional[str]:
-        """Extract specific code block by name."""
-        with open(file_path, 'r', encoding='utf-8') as f:
-            lines = f.readlines()
-
-        # Try functions first
-        functions = self.list_functions(file_path, language)
-        for func in functions:
-            if func.name == block_name:
-                return ''.join(lines[func.line_start - 1:func.line_end])
-
-        # Try classes
-        classes = self.list_classes(file_path, language)
-        for cls in classes:
-            if cls.name == block_name:
-                return ''.join(lines[cls.line_start - 1:cls.line_end])
-
-        return None
-
-
-# =============================================================================
-# Regex Fallback Parser
-# =============================================================================
-
-class RegexParser:
-    """Fallback parser using regex patterns when tree-sitter unavailable."""
-
-    # Regex patterns for function detection by language
-    FUNCTION_PATTERNS = {
-        'kotlin': [
-            # Regular function: fun name(...)
-            r'^\s*(private|public|internal|protected|override|suspend|inline|)?\s*fun\s+(\w+)\s*\(',
-            # Extension function: fun Type.name(...)
-            r'^\s*(private|public|internal|protected|override|suspend|inline|)?\s*fun\s+\w+\.(\w+)\s*\(',
-        ],
-        'java': [
-            # Method: modifier type name(...)
-            r'^\s*(public|private|protected|static|final|abstract|synchronized|native|)?\s*[\w<>\[\],\s]+\s+(\w+)\s*\([^)]*\)\s*(\{|throws)',
-        ],
-        'javascript': [
-            # function declaration
-            r'^\s*(async\s+)?function\s+(\w+)\s*\(',
-            # method in class
-            r'^\s*(async\s+)?(\w+)\s*\([^)]*\)\s*\{',
-            # arrow function assigned to const/let/var
-            r'^\s*(const|let|var)\s+(\w+)\s*=\s*(async\s+)?\([^)]*\)\s*=>',
-        ],
-        'typescript': [
-            # function declaration
-            r'^\s*(export\s+)?(async\s+)?function\s+(\w+)',
-            # method in class
-            r'^\s*(public|private|protected|static|async|)?\s*(\w+)\s*\([^)]*\)(\s*:\s*[\w<>\[\]|]+)?\s*\{',
-        ],
-        'go': [
-            # Regular function
-            r'^\s*func\s+(\w+)\s*\(',
-            # Method with receiver
-            r'^\s*func\s+\([^)]+\)\s+(\w+)\s*\(',
-        ],
-        'swift': [
-            # Function declaration
-            r'^\s*(private|public|internal|fileprivate|open|override|static|class|)?\s*func\s+(\w+)\s*[(<]',
-            # Init
-            r'^\s*(required|convenience|override|)?\s*init\s*[(<\?]',
-        ],
-        'rust': [
-            # Function
-            r'^\s*(pub\s+)?(async\s+)?fn\s+(\w+)\s*[(<]',
-        ],
-        'c': [
-            # Function definition
-            r'^\s*(static\s+)?(inline\s+)?[\w\s\*]+\s+(\w+)\s*\([^;]*$',
-        ],
-        'cpp': [
-            # Function/method
-            r'^\s*(static\s+)?(inline\s+)?(virtual\s+)?[\w\s\*:]+\s+(\w+)\s*\([^;]*$',
-        ],
-    }
-
-    CLASS_PATTERNS = {
-        'kotlin': [
-            r'^\s*(data\s+|sealed\s+|abstract\s+|open\s+|internal\s+|private\s+|)?(class|interface|object|enum\s+class)\s+(\w+)',
-        ],
-        'java': [
-            r'^\s*(public\s+|private\s+|protected\s+)?(abstract\s+|final\s+|static\s+)?(class|interface|enum)\s+(\w+)',
-        ],
-        'javascript': [
-            r'^\s*(export\s+)?(default\s+)?class\s+(\w+)',
-        ],
-        'typescript': [
-            r'^\s*(export\s+)?(abstract\s+)?class\s+(\w+)',
-            r'^\s*(export\s+)?interface\s+(\w+)',
-        ],
-        'go': [
-            r'^\s*type\s+(\w+)\s+(struct|interface)\s*\{',
-        ],
-        'swift': [
-            r'^\s*(public\s+|private\s+|internal\s+|fileprivate\s+|open\s+|final\s+)?(class|struct|protocol|enum)\s+(\w+)',
-        ],
-        'rust': [
-            r'^\s*(pub\s+)?struct\s+(\w+)',
-            r'^\s*(pub\s+)?trait\s+(\w+)',
-            r'^\s*(pub\s+)?enum\s+(\w+)',
-        ],
-    }
-
-    # Brace matching for finding block end
-    BRACE_LANGUAGES = ['kotlin', 'java', 'javascript', 'typescript', 'go', 'swift', 'rust', 'c', 'cpp', 'c_sharp']
-
-    def list_functions(self, file_path: Path, language: str) -> List[CodeBlock]:
-        """List functions using regex patterns."""
-        patterns = self.FUNCTION_PATTERNS.get(language, [])
-        if not patterns:
-            return []
-
-        with open(file_path, 'r', encoding='utf-8') as f:
-            lines = f.readlines()
-
-        functions = []
-
-        for i, line in enumerate(lines):
-            for pattern in patterns:
-                match = re.match(pattern, line)
-                if match:
-                    # Get function name (last captured group typically)
-                    groups = [g for g in match.groups() if g]
-                    if groups:
-                        name = groups[-1].strip()
-                        if name and name not in ['async', 'function', 'const', 'let', 'var']:
-                            line_start = i + 1
-                            line_end = self._find_block_end(lines, i, language)
-
-                            functions.append(CodeBlock(
-                                name=name,
-                                block_type='function',
-                                line_start=line_start,
-                                line_end=line_end,
-                                signature=line.strip()
-                            ))
-                    break
-
-        return functions
-
-    def list_classes(self, file_path: Path, language: str) -> List[CodeBlock]:
-        """List classes using regex patterns."""
-        patterns = self.CLASS_PATTERNS.get(language, [])
-        if not patterns:
-            return []
-
-        with open(file_path, 'r', encoding='utf-8') as f:
-            lines = f.readlines()
-
-        classes = []
-
-        for i, line in enumerate(lines):
-            for pattern in patterns:
-                match = re.match(pattern, line)
-                if match:
-                    groups = [g for g in match.groups() if g and g.strip()]
-                    if groups:
-                        name = groups[-1].strip()
-                        # Filter out keywords
-                        if name and name not in ['class', 'interface', 'struct', 'enum', 'object', 'protocol', 'trait']:
-                            line_start = i + 1
-                            line_end = self._find_block_end(lines, i, language)
-
-                            # Determine type
-                            block_type = 'class'
-                            if 'interface' in line.lower():
-                                block_type = 'interface'
-                            elif 'struct' in line.lower():
-                                block_type = 'struct'
-                            elif 'enum' in line.lower():
-                                block_type = 'enum'
-                            elif 'protocol' in line.lower() or 'trait' in line.lower():
-                                block_type = 'protocol'
-                            elif 'object' in line.lower():
-                                block_type = 'object'
-
-                            classes.append(CodeBlock(
-                                name=name,
-                                block_type=block_type,
-                                line_start=line_start,
-                                line_end=line_end,
-                                signature=line.strip()
-                            ))
-                    break
-
-        return classes
-
-    def _find_block_end(self, lines: List[str], start_line: int, language: str) -> int:
-        """Find the end of a code block using brace matching."""
-        if language not in self.BRACE_LANGUAGES:
-            # For Python-like languages, use indentation
-            return self._find_block_end_indent(lines, start_line)
-
-        brace_count = 0
-        in_string = False
-        string_char = None
-        found_first_brace = False
-
-        for i in range(start_line, len(lines)):
-            line = lines[i]
-            j = 0
-            while j < len(line):
-                char = line[j]
-
-                # Handle strings
-                if char in '"\'`' and (j == 0 or line[j-1] != '\\'):
-                    if not in_string:
-                        in_string = True
-                        string_char = char
-                    elif char == string_char:
-                        in_string = False
-                        string_char = None
-                elif not in_string:
-                    if char == '{':
-                        brace_count += 1
-                        found_first_brace = True
-                    elif char == '}':
-                        brace_count -= 1
-                        if found_first_brace and brace_count == 0:
-                            return i + 1
-
-                j += 1
-
-        return len(lines)
-
-    def _find_block_end_indent(self, lines: List[str], start_line: int) -> int:
-        """Find block end using indentation (Python-style)."""
-        if start_line >= len(lines):
-            return start_line + 1
-
-        # Get starting indentation
-        start_indent = len(lines[start_line]) - len(lines[start_line].lstrip())
-
-        for i in range(start_line + 1, len(lines)):
-            line = lines[i]
-            stripped = line.strip()
-
-            # Skip empty lines and comments
-            if not stripped or stripped.startswith('#'):
-                continue
-
-            current_indent = len(line) - len(line.lstrip())
-            if current_indent <= start_indent and stripped:
-                return i
-
-        return len(lines)
-
-    def get_block(self, file_path: Path, block_name: str, language: str) -> Optional[str]:
-        """Extract specific code block by name."""
-        with open(file_path, 'r', encoding='utf-8') as f:
-            lines = f.readlines()
-
-        # Try functions
-        functions = self.list_functions(file_path, language)
-        for func in functions:
-            if func.name == block_name:
-                return ''.join(lines[func.line_start - 1:func.line_end])
-
-        # Try classes
-        classes = self.list_classes(file_path, language)
-        for cls in classes:
-            if cls.name == block_name:
-                return ''.join(lines[cls.line_start - 1:cls.line_end])
-
-        return None
-
-
-# =============================================================================
-# Unified Parser Interface
-# =============================================================================
-
-class MultiLanguageParser:
-    """
-    Unified parser interface that automatically selects the best parsing strategy.
-
-    Priority:
-    1. Python AST (for .py files - most accurate)
-    2. Tree-sitter (for supported languages - fast and accurate)
-    3. Regex patterns (fallback - works everywhere)
-    """
-
-    def __init__(self):
-        self.tree_sitter_parser = TreeSitterParser() if TREE_SITTER_AVAILABLE else None
-        self.regex_parser = RegexParser()
-
-    def list_functions(self, file_path: Path, language: str = None) -> List[CodeBlock]:
-        """
-        List all functions/methods in a file.
-
-        Args:
-            file_path: Path to source file
-            language: Programming language (auto-detected if not provided)
-
-        Returns:
-            List of CodeBlock objects with function info
-        """
-        if language is None:
-            language = detect_language(file_path)
-
-        # Try tree-sitter first (fastest and most accurate)
-        if self.tree_sitter_parser:
-            try:
-                result = self.tree_sitter_parser.list_functions(file_path, language)
-                if result:
-                    return result
-            except Exception:
-                pass
-
-        # Fallback to regex
-        return self.regex_parser.list_functions(file_path, language)
-
-    def list_classes(self, file_path: Path, language: str = None) -> List[CodeBlock]:
-        """
-        List all classes/interfaces in a file.
-
-        Args:
-            file_path: Path to source file
-            language: Programming language (auto-detected if not provided)
-
-        Returns:
-            List of CodeBlock objects with class info
-        """
-        if language is None:
-            language = detect_language(file_path)
-
-        # Try tree-sitter first
-        if self.tree_sitter_parser:
-            try:
-                result = self.tree_sitter_parser.list_classes(file_path, language)
-                if result:
-                    return result
-            except Exception:
-                pass
-
-        # Fallback to regex
-        return self.regex_parser.list_classes(file_path, language)
-
-    def get_function(self, file_path: Path, function_name: str, language: str = None) -> Optional[str]:
-        """
-        Extract specific function code.
-
-        Args:
-            file_path: Path to source file
-            function_name: Name of function to extract
-            language: Programming language (auto-detected if not provided)
-
-        Returns:
-            Function code as string, or None if not found
-        """
-        if language is None:
-            language = detect_language(file_path)
-
-        with open(file_path, 'r', encoding='utf-8') as f:
-            lines = f.readlines()
-
-        functions = self.list_functions(file_path, language)
-        for func in functions:
-            if func.name == function_name:
-                return ''.join(lines[func.line_start - 1:func.line_end])
-
-        return None
-
-    def get_class(self, file_path: Path, class_name: str, language: str = None) -> Optional[str]:
-        """
-        Extract specific class code.
-
-        Args:
-            file_path: Path to source file
-            class_name: Name of class to extract
-            language: Programming language (auto-detected if not provided)
-
-        Returns:
-            Class code as string, or None if not found
-        """
-        if language is None:
-            language = detect_language(file_path)
-
-        with open(file_path, 'r', encoding='utf-8') as f:
-            lines = f.readlines()
-
-        classes = self.list_classes(file_path, language)
-        for cls in classes:
-            if cls.name == class_name:
-                return ''.join(lines[cls.line_start - 1:cls.line_end])
-
-        return None
-
-    def get_imports(self, file_path: Path, language: str = None) -> str:
-        """
-        Extract import statements from file.
-
-        Args:
-            file_path: Path to source file
-            language: Programming language (auto-detected if not provided)
-
-        Returns:
-            Import statements as string
-        """
-        if language is None:
-            language = detect_language(file_path)
-
-        with open(file_path, 'r', encoding='utf-8') as f:
-            lines = f.readlines()
-
-        import_patterns = {
-            'kotlin': r'^\s*(import\s+.+)$',
-            'java': r'^\s*(import\s+.+;)$',
-            'javascript': r'^\s*(import\s+.+|const\s+\{?.+\}?\s*=\s*require\(.+\).*)$',
-            'typescript': r'^\s*(import\s+.+)$',
-            'go': r'^\s*(import\s+.+|import\s+\()$',
-            'swift': r'^\s*(import\s+\w+)$',
-            'rust': r'^\s*(use\s+.+;|extern\s+crate\s+.+;)$',
-            'c': r'^\s*(#include\s+[<"].+[>"])$',
-            'cpp': r'^\s*(#include\s+[<"].+[>"]|using\s+.+;)$',
-            'python': r'^\s*(import\s+.+|from\s+.+\s+import\s+.+)$',
-        }
-
-        pattern = import_patterns.get(language)
-        if not pattern:
-            return ""
-
-        imports = []
-        in_multiline_import = False
-
-        for line in lines:
-            # Handle Go's multi-line imports
-            if language == 'go':
-                if 'import (' in line:
-                    in_multiline_import = True
-                    imports.append(line)
-                    continue
-                elif in_multiline_import:
-                    imports.append(line)
-                    if ')' in line:
-                        in_multiline_import = False
-                    continue
-
-            if re.match(pattern, line):
-                imports.append(line)
-            elif imports and not line.strip():
-                # Stop at first non-import, non-blank line after imports started
-                continue
-            elif imports and not re.match(pattern, line) and line.strip():
-                break
-
-        return ''.join(imports)
-
-
-# =============================================================================
-# CLI Interface
-# =============================================================================
-
-if __name__ == '__main__':
-    import sys
-    import json
-
-    def print_usage():
-        print("""
-Multi-Language Code Parser
-
-Usage:
-    python language_parsers.py list-functions <file>
-    python language_parsers.py list-classes <file>
-    python language_parsers.py get-function <file> <name>
-    python language_parsers.py get-class <file> <name>
-    python language_parsers.py get-imports <file>
-    python language_parsers.py detect <file>
-
-Supported Languages:
-    Kotlin (.kt), Java (.java), Swift (.swift)
-    JavaScript (.js, .jsx), TypeScript (.ts, .tsx)
-    Go (.go), Rust (.rs)
-    C (.c, .h), C++ (.cpp, .hpp)
-    Python (.py), Ruby (.rb), PHP (.php)
-
-Examples:
-    python language_parsers.py list-functions app/src/main/java/MyClass.kt
-    python language_parsers.py get-function src/utils.ts calculateTotal
-    python language_parsers.py get-class main.go Server
-""")
-
-    if len(sys.argv) < 3:
-        print_usage()
-        sys.exit(1)
-
-    command = sys.argv[1]
-    file_path = Path(sys.argv[2])
-
-    if not file_path.exists():
-        print(f"Error: File not found: {file_path}", file=sys.stderr)
-        sys.exit(1)
-
-    parser = MultiLanguageParser()
-    language = detect_language(file_path)
-
-    if command == 'detect':
-        print(f"Language: {language}")
-        print(f"Tree-sitter available: {TREE_SITTER_AVAILABLE}")
-
-    elif command == 'list-functions':
-        functions = parser.list_functions(file_path)
-        if not functions:
-            print("No functions found")
-        else:
-            print(f"\nFound {len(functions)} functions in {file_path} ({language}):\n")
-            for func in functions:
-                parent = f" [{func.parent_class}]" if func.parent_class else ""
-                print(f"  {func.block_type}: {func.name}{parent}")
-                print(f"    Lines: {func.line_start}-{func.line_end}")
-                if func.signature:
-                    print(f"    Sig: {func.signature[:60]}...")
-                print()
-
-    elif command == 'list-classes':
-        classes = parser.list_classes(file_path)
-        if not classes:
-            print("No classes found")
-        else:
-            print(f"\nFound {len(classes)} classes in {file_path} ({language}):\n")
-            for cls in classes:
-                print(f"  {cls.block_type}: {cls.name}")
-                print(f"    Lines: {cls.line_start}-{cls.line_end}")
-                print()
-
-    elif command == 'get-function':
-        if len(sys.argv) < 4:
-            print("Error: Function name required", file=sys.stderr)
-            sys.exit(1)
-        func_name = sys.argv[3]
-        code = parser.get_function(file_path, func_name)
-        if code:
-            print(code)
-        else:
-            print(f"Function '{func_name}' not found", file=sys.stderr)
-            sys.exit(1)
-
-    elif command == 'get-class':
-        if len(sys.argv) < 4:
-            print("Error: Class name required", file=sys.stderr)
-            sys.exit(1)
-        class_name = sys.argv[3]
-        code = parser.get_class(file_path, class_name)
-        if code:
-            print(code)
-        else:
-            print(f"Class '{class_name}' not found", file=sys.stderr)
-            sys.exit(1)
-
-    elif command == 'get-imports':
-        imports = parser.get_imports(file_path)
-        if imports:
-            print(imports)
-        else:
-            print("No imports found")
-
-    else:
-        print(f"Unknown command: {command}", file=sys.stderr)
-        print_usage()
-        sys.exit(1)