@mc1global/opencode-jarvis 0.12.0 → 0.13.1

package/scripts/parsers/language_parsers.py

@@ -0,0 +1,966 @@
+#!/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)