codegraphcontext-rust 0.5.5__cp310-cp310-win_amd64.whl

codegraphcontext/tools/languages/javascript.py

@@ -0,0 +1,589 @@
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+import re
+from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logger, warning_logger
+from codegraphcontext.utils.tree_sitter_manager import execute_query
+
+# --- Helpers to classify JS methods ---
+_GETTER_RE = re.compile(r"^\s*(?:static\s+)?get\b")
+_SETTER_RE = re.compile(r"^\s*(?:static\s+)?set\b")
+_STATIC_RE = re.compile(r"^\s*static\b")
+
+
+def _first_line_before_body(text: str) -> str:
+    """
+    Best-effort header extraction: take text before the first '{'
+    (covers class/object methods). Fallback to the first line.
+    """
+    head = text.split("{", 1)[0]
+    if not head.strip():
+        return text.splitlines()[0] if text.splitlines() else text
+    return head
+
+
+def _classify_method_kind(header: str) -> Optional[str]:
+    """
+    Return 'getter' | 'setter' | 'static' | None.
+    Prefer 'getter'/'setter' over 'static' when both appear.
+    """
+    if _GETTER_RE.search(header):
+        return "getter"
+    if _SETTER_RE.search(header):
+        return "setter"
+    if _STATIC_RE.search(header):
+        return "static"
+    return None
+
+
+JS_QUERIES = {
+    "functions": """
+        (function_declaration 
+            name: (identifier) @name
+            parameters: (formal_parameters) @params
+        ) @function_node
+        
+        (variable_declarator 
+            name: (identifier) @name 
+            value: (function_expression 
+                parameters: (formal_parameters) @params
+            ) @function_node
+        )
+        
+        (variable_declarator 
+            name: (identifier) @name 
+            value: (arrow_function 
+                parameters: (formal_parameters) @params
+            ) @function_node
+        )
+        
+        (variable_declarator 
+            name: (identifier) @name 
+            value: (arrow_function 
+                parameter: (identifier) @single_param
+            ) @function_node
+        )
+        
+        (method_definition 
+            name: (property_identifier) @name
+            parameters: (formal_parameters) @params
+        ) @function_node
+        
+        (assignment_expression
+            left: (member_expression 
+                property: (property_identifier) @name
+            )
+            right: (function_expression
+                parameters: (formal_parameters) @params
+            ) @function_node
+        )
+        
+        (assignment_expression
+            left: (member_expression 
+                property: (property_identifier) @name
+            )
+            right: (arrow_function
+                parameters: (formal_parameters) @params
+            ) @function_node
+        )
+    """,
+    "classes": """
+        (class_declaration) @class
+        (class) @class
+    """,
+    "imports": """
+        (import_statement) @import
+        (call_expression
+            function: (identifier) @require_call (#eq? @require_call "require")
+        ) @import
+    """,
+    "calls": """
+        (call_expression function: (identifier) @name)
+        (call_expression function: (member_expression property: (property_identifier) @name))
+        (new_expression constructor: (identifier) @name)
+        (new_expression constructor: (member_expression property: (property_identifier) @name))
+    """,
+    "variables": """
+        (variable_declarator name: (identifier) @name)
+    """,
+    "docstrings": """
+        (comment) @docstring_comment
+    """,
+}
+
+
+class JavascriptTreeSitterParser:
+    """A JavaScript-specific parser using tree-sitter, encapsulating language-specific logic."""
+
+    def __init__(self, generic_parser_wrapper):
+        self.generic_parser_wrapper = generic_parser_wrapper
+        self.language_name = generic_parser_wrapper.language_name
+        self.language = generic_parser_wrapper.language
+        self.parser = generic_parser_wrapper.parser
+
+    def _get_node_text(self, node) -> str:
+        return node.text.decode('utf-8')
+
+    def _get_parent_context(self, node, types=('function_declaration', 'class_declaration', 'function_expression', 'method_definition', 'arrow_function')):
+        # JS specific context types
+        curr = node.parent
+        while curr:
+            if curr.type in types:
+                name_node = curr.child_by_field_name('name')
+                if not name_node and curr.type in ('function_expression', 'arrow_function'):
+                    # Try to find name from variable declaration
+                    if curr.parent and curr.parent.type == 'variable_declarator':
+                        name_node = curr.parent.child_by_field_name('name')
+                    elif curr.parent and curr.parent.type == 'assignment_expression':
+                        name_node = curr.parent.child_by_field_name('left')
+                    elif curr.parent and curr.parent.type == 'pair': # property: function
+                        name_node = curr.parent.child_by_field_name('key')
+                
+                return self._get_node_text(name_node) if name_node else None, curr.type, curr.start_point[0] + 1
+            curr = curr.parent
+        return None, None, None
+
+    def _calculate_complexity(self, node):
+        # JS specific complexity nodes
+        complexity_nodes = {
+            "if_statement", "for_statement", "while_statement", "do_statement",
+            "switch_statement", "case_statement", "conditional_expression",
+            "logical_expression", "binary_expression", "catch_clause"
+        }
+        count = 1
+
+        def traverse(n):
+            nonlocal count
+            if n.type in complexity_nodes:
+                count += 1
+            for child in n.children:
+                traverse(child)
+
+        traverse(node)
+        return count
+
+    def _get_docstring(self, body_node):
+        # JS specific docstring extraction (e.g., JSDoc comments)
+        # This is a placeholder and needs more sophisticated logic
+        return None
+
+    def parse(self, path: Path, is_dependency: bool = False, index_source: bool = False) -> Dict[str, Any]:
+        """Parses a file and returns its structure in a standardized dictionary format."""
+        self.index_source = index_source
+        with open(path, "r", encoding="utf-8") as f:
+            source_code = f.read()
+
+        tree = self.parser.parse(bytes(source_code, "utf8"))
+        root_node = tree.root_node
+
+        functions = self._find_functions(root_node)
+        classes = self._find_classes(root_node)
+        imports = self._find_imports(root_node)
+        function_calls = self._find_calls(root_node)
+        variables = self._find_variables(root_node)
+
+        return {
+            "path": str(path),
+            "functions": functions,
+            "classes": classes,
+            "variables": variables,
+            "imports": imports,
+            "function_calls": function_calls,
+            "is_dependency": is_dependency,
+            "lang": self.language_name,
+        }
+
+    def _find_functions(self, root_node):
+        functions = []
+        query_str = JS_QUERIES['functions']
+
+        # Local helpers so we don't depend on class attrs being present
+        def _fn_for_name(name_node):
+            current = name_node.parent
+            while current:
+                if current.type in ('function_declaration', 'function', 'arrow_function', 'method_definition', 'function_expression'):
+                    return current
+                elif current.type in ('variable_declarator', 'assignment_expression'):
+                    for child in current.children:
+                        if child.type in ('function', 'arrow_function', 'function_expression'):
+                            return child
+                current = current.parent
+            return None
+
+        def _fn_for_params(params_node):
+            current = params_node.parent
+            while current:
+                if current.type in ('function_declaration', 'function', 'arrow_function', 'method_definition', 'function_expression'):
+                    return current
+                current = current.parent
+            return None
+        # stable keys so the same function only gets one bucket
+        def _key(n):  # start/end byte + type is stable across captures
+            return (n.start_byte, n.end_byte, n.type)
+
+        # Collect captures grouped by function node
+        captures_by_function = {}
+        def _bucket_for(node):
+            fid = _key(node)
+            return captures_by_function.setdefault(fid, {
+                'node': node, 'name': None, 'params': None, 'single_param': None
+            })
+
+        for node, capture_name in execute_query(self.language, query_str, root_node):
+            if capture_name == 'function_node':
+                _bucket_for(node)
+            elif capture_name == 'name':
+                fn = _fn_for_name(node)
+                if fn:
+                    b = _bucket_for(fn)
+                    b['name'] = self._get_node_text(node)
+            elif capture_name == 'params':
+                fn = _fn_for_params(node)
+                if fn:
+                    b = _bucket_for(fn)
+                    b['params'] = node
+            elif capture_name == 'single_param':
+                fn = _fn_for_params(node)
+                if fn:
+                    b = _bucket_for(fn)
+                    b['single_param'] = node
+
+        # Build Function entries
+        for _, data in captures_by_function.items():
+            func_node = data['node']
+
+            # Backfill name for method_definition if query didn't capture it
+            name = data.get('name')
+            if not name and func_node.type == 'method_definition':
+                nm = func_node.child_by_field_name('name')
+                if nm:
+                    name = self._get_node_text(nm)
+            if not name:
+                continue  # skip nameless functions
+
+            # Parameters
+            args = []
+            if data.get('params'):
+                args = self._extract_parameters(data['params'])
+            elif data.get('single_param'):
+                args = [self._get_node_text(data['single_param'])]
+
+            # Context & docstring
+            context, context_type, _ = self._get_parent_context(func_node)
+            class_context = context if context_type == 'class_declaration' else None
+            docstring = self._get_jsdoc_comment(func_node)
+
+            # Classify getter/setter/static (methods only)
+            js_kind = None
+            if func_node.type == 'method_definition':
+                header = _first_line_before_body(self._get_node_text(func_node))
+                js_kind = _classify_method_kind(header)
+
+            func_data = {
+                "name": name,
+                "line_number": func_node.start_point[0] + 1,
+                "end_line": func_node.end_point[0] + 1,
+                "args": args,
+                "lang": self.language_name,
+                "is_dependency": False,
+            }
+
+            if self.index_source:
+                func_data["source"] = self._get_node_text(func_node)
+                func_data["docstring"] = docstring
+            if js_kind is not None:
+                func_data["type"] = js_kind
+
+            functions.append(func_data)
+
+        return functions
+
+
+
+    def _find_function_node_for_name(self, name_node):
+        """Find the function node that contains this name node."""
+        current = name_node.parent
+        while current:
+            if current.type in ('function_declaration', 'function', 'arrow_function', 'method_definition'):
+                return current
+            elif current.type in ('variable_declarator', 'assignment_expression'):
+                # Check if this declarator/assignment contains a function
+                for child in current.children:
+                    if child.type in ('function', 'arrow_function'):
+                        return child
+            current = current.parent
+        return None
+
+
+    def _find_function_node_for_params(self, params_node):
+        """Find the function node that contains this parameters node."""
+        current = params_node.parent
+        while current:
+            if current.type in ('function_declaration', 'function', 'arrow_function', 'method_definition'):
+                return current
+            current = current.parent
+
+        return None
+
+
+    def _extract_parameters(self, params_node):
+        """Extract parameter names from formal_parameters node."""
+        params = []
+        if params_node.type == 'formal_parameters':
+            for child in params_node.children:
+                if child.type == 'identifier':
+                    params.append(self._get_node_text(child))
+                elif child.type == 'assignment_pattern':
+                    # Default parameter: param = defaultValue
+                    left_child = child.child_by_field_name('left')
+                    if left_child and left_child.type == 'identifier':
+                        params.append(self._get_node_text(left_child))
+                elif child.type == 'rest_pattern':
+                    # Rest parameter: ...args
+                    argument = child.child_by_field_name('argument')
+                    if argument and argument.type == 'identifier':
+                        params.append(f"...{self._get_node_text(argument)}")
+        return params
+
+
+    def _get_jsdoc_comment(self, func_node):
+        """Extract JSDoc comment preceding the function."""
+        # Look for comments before the function
+        prev_sibling = func_node.prev_sibling
+        while prev_sibling and prev_sibling.type in ('comment', '\n', ' '):
+            if prev_sibling.type == 'comment':
+                comment_text = self._get_node_text(prev_sibling)
+                if comment_text.startswith('/**') and comment_text.endswith('*/'):
+                    return comment_text.strip()
+            prev_sibling = prev_sibling.prev_sibling
+        return None
+
+
+    def _find_classes(self, root_node):
+        classes = []
+        query_str = JS_QUERIES['classes']
+        for class_node, capture_name in execute_query(self.language, query_str, root_node):
+            if capture_name == 'class':
+                name_node = class_node.child_by_field_name('name')
+                if not name_node: continue
+                name = self._get_node_text(name_node)
+
+                bases = []
+                heritage_node = next((child for child in class_node.children if child.type == 'class_heritage'), None)
+                if heritage_node:
+                    if heritage_node.named_child_count > 0:
+                        base_expr_node = heritage_node.named_child(0)
+                        bases.append(self._get_node_text(base_expr_node))
+                    elif heritage_node.child_count > 0:
+                        # Fallback for anonymous nodes
+                        base_expr_node = heritage_node.child(heritage_node.child_count - 1)
+                        bases.append(self._get_node_text(base_expr_node))
+
+                class_data = {
+                    "name": name,
+                    "line_number": class_node.start_point[0] + 1,
+                    "end_line": class_node.end_point[0] + 1,
+                    "bases": bases,
+                    "context": None,
+                    "decorators": [],
+                    "lang": self.language_name,
+                    "is_dependency": False,
+                }
+
+                if self.index_source:
+                    class_data["source"] = self._get_node_text(class_node)
+                    class_data["docstring"] = self._get_docstring(class_node)
+
+                classes.append(class_data)
+        return classes
+
+
+    def _find_imports(self, root_node):
+        imports = []
+        query_str = JS_QUERIES['imports']
+        for node, capture_name in execute_query(self.language, query_str, root_node):
+            if capture_name != 'import':
+                continue
+
+            line_number = node.start_point[0] + 1
+
+            if node.type == 'import_statement':
+                source = self._get_node_text(node.child_by_field_name('source')).strip('\'"')
+
+                # Look for different import structures
+                import_clause = node.child_by_field_name('import')
+                if not import_clause:
+                    imports.append({'name': source, 'source': source, 'alias': None, 'line_number': line_number,
+                                    'lang': self.language_name})
+                    continue
+
+                # Default import: import defaultExport from '...'
+                if import_clause.type == 'identifier':
+                    alias = self._get_node_text(import_clause)
+                    imports.append({'name': 'default', 'source': source, 'alias': alias, 'line_number': line_number,
+                                    'lang': self.language_name})
+
+                # Namespace import: import * as name from '...'
+                elif import_clause.type == 'namespace_import':
+                    alias_node = import_clause.child_by_field_name('alias')
+                    if alias_node:
+                        alias = self._get_node_text(alias_node)
+                        imports.append({'name': '*', 'source': source, 'alias': alias, 'line_number': line_number,
+                                        'lang': self.language_name})
+
+                # Named imports: import { name, name as alias } from '...'
+                elif import_clause.type == 'named_imports':
+                    for specifier in import_clause.children:
+                        if specifier.type == 'import_specifier':
+                            name_node = specifier.child_by_field_name('name')
+                            alias_node = specifier.child_by_field_name('alias')
+                            original_name = self._get_node_text(name_node)
+                            alias = self._get_node_text(alias_node) if alias_node else None
+                            imports.append(
+                                {'name': original_name, 'source': source, 'alias': alias, 'line_number': line_number,
+                                 'lang': self.language_name})
+
+            elif node.type == 'call_expression':  # require('...')
+                args = node.child_by_field_name('arguments')
+                if not args or args.named_child_count == 0: continue
+                source_node = args.named_child(0)
+                if not source_node or source_node.type != 'string': continue
+                source = self._get_node_text(source_node).strip('\'"')
+
+                alias = None
+                if node.parent.type == 'variable_declarator':
+                    alias_node = node.parent.child_by_field_name('name')
+                    if alias_node:
+                        alias = self._get_node_text(alias_node)
+                imports.append({'name': source, 'source': source, 'alias': alias, 'line_number': line_number,
+                                'lang': self.language_name})
+
+        return imports
+
+
+    def _find_calls(self, root_node):
+        calls = []
+        query_str = JS_QUERIES['calls']
+        for node, capture_name in execute_query(self.language, query_str, root_node):
+            # Placeholder for JS call extraction logic
+            if capture_name == 'name':
+                # Traverse up to find the call_expression
+                call_node = node.parent
+                while call_node and call_node.type != 'call_expression' and call_node.type != 'program':
+                    call_node = call_node.parent
+                
+                name = self._get_node_text(node)
+
+                # Improved args extraction
+                args = []
+                arguments_node = None
+                if call_node and call_node.type in ('call_expression', 'new_expression'):
+                    arguments_node = call_node.child_by_field_name('arguments')
+                
+                if arguments_node:
+                    for arg in arguments_node.children:
+                        if arg.type not in ('(', ')', ','):
+                            args.append(self._get_node_text(arg))
+
+                call_data = {
+                    "name": name,
+                    "full_name": self._get_node_text(call_node),
+                    "line_number": node.start_point[0] + 1,
+                    "args": args,
+                    "inferred_obj_type": None,
+                    "context": self._get_parent_context(node),
+                    "class_context": self._get_parent_context(node, types=('class_declaration',))[:2],
+                    "lang": self.language_name,
+                    "is_dependency": False,
+                }
+                calls.append(call_data)
+        return calls
+
+
+    def _find_variables(self, root_node):
+        variables = []
+        query_str = JS_QUERIES['variables']
+        for match in execute_query(self.language, query_str, root_node):
+            capture_name = match[1]
+            node = match[0]
+
+            if capture_name == 'name':
+                var_node = node.parent
+                name = self._get_node_text(node)
+                value = None 
+                type_text = None
+
+                # Detect if variable assigned to a function
+                value_node = var_node.child_by_field_name("value") if var_node else None
+
+                if value_node:
+                    value_type = value_node.type
+
+                    # --- Skip variables that are assigned a function ---
+                    if value_type in ("function_expression", "arrow_function"):
+                        continue
+                    
+                    # Some grammars might have async_arrow_function or similar
+                    if "function" in value_type or "arrow" in value_type:
+                        continue
+
+                    # --- Handle various assignment types ---
+                    if value_type == "call_expression":
+                        func_node = value_node.child_by_field_name("function")
+                        value = self._get_node_text(func_node) if func_node else name
+                    else:
+                        value = self._get_node_text(value_node)
+
+                context, context_type, context_line = self._get_parent_context(node)
+                class_context = context if context_type == 'class_declaration' else None
+
+                variable_data = {
+                    "name": name,
+                    "line_number": node.start_point[0] + 1,
+                    "value": value,
+                    "type": type_text,
+                    "context": context,
+                    "class_context": class_context,
+                    "lang": self.language_name,
+                    "is_dependency": False,
+                }
+                variables.append(variable_data)
+        return variables
+
+
+def pre_scan_javascript(files: list[Path], parser_wrapper) -> dict:
+    """Scans JavaScript files to create a map of class/function names to their file paths."""
+    imports_map = {}
+    query_str = """
+        (class_declaration name: (identifier) @name)
+        (function_declaration name: (identifier) @name)
+        (variable_declarator name: (identifier) @name value: (function_expression))
+        (variable_declarator name: (identifier) @name value: (arrow_function))
+        (method_definition name: (property_identifier) @name)
+        (assignment_expression
+            left: (member_expression 
+                property: (property_identifier) @name
+            )
+            right: (function_expression)
+        )
+        (assignment_expression
+            left: (member_expression 
+                property: (property_identifier) @name
+            )
+            right: (arrow_function)
+        )
+    """
+    
+
+    for path in files:
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                tree = parser_wrapper.parser.parse(bytes(f.read(), "utf8"))
+
+            for capture, _ in execute_query(parser_wrapper.language, query_str, tree.root_node):
+                name = capture.text.decode('utf-8')
+                if name not in imports_map:
+                    imports_map[name] = []
+                imports_map[name].append(str(path.resolve()))
+        except Exception as e:
+            warning_logger(f"Tree-sitter pre-scan failed for {path}: {e}")
+    return imports_map