agentcrew-ai 0.8.12__py3-none-any.whl → 0.8.13__py3-none-any.whl

AgentCrew/modules/code_analysis/parsers/go_parser.py

@@ -0,0 +1,154 @@
+"""
+Go language parser for code analysis.
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class GoParser(BaseLanguageParser):
+    """Parser for Go source code."""
+
+    @property
+    def language_name(self) -> str:
+        return "go"
+
+    def process_node(
+        self, node, source_code: bytes, process_children_callback
+    ) -> Optional[Dict[str, Any]]:
+        result = self._create_base_result(node)
+
+        if node.type == "type_declaration":
+            return self._handle_type_declaration(
+                node, source_code, result, process_children_callback
+            )
+
+        elif node.type in ["function_declaration", "method_declaration"]:
+            for child in node.children:
+                if child.type in ["identifier", "field_identifier"]:
+                    result["name"] = self.extract_node_text(child, source_code)
+                    result["first_line"] = (
+                        self.extract_node_text(node, source_code)
+                        .split("\n")[0]
+                        .strip("{")
+                    )
+                    return result
+            return result
+
+        elif node.type == "interface_declaration":
+            for child in node.children:
+                if child.type == "identifier":
+                    result["name"] = self.extract_node_text(child, source_code)
+                    return result
+            return result
+
+        elif node.type in ["var_declaration", "const_declaration"]:
+            return self._handle_var_declaration(node, source_code, result)
+
+        elif node.type == "field_declaration":
+            return self._handle_field_declaration(node, source_code, result)
+
+        children = []
+        for child in node.children:
+            child_result = process_children_callback(child)
+            if child_result and self._is_significant_node(child_result):
+                children.append(child_result)
+
+        if children:
+            result["children"] = children
+
+        return result
+
+    def _handle_type_declaration(
+        self,
+        node,
+        source_code: bytes,
+        result: Dict[str, Any],
+        process_children_callback,
+    ) -> Dict[str, Any]:
+        for child in node.children:
+            if child.type == "type_spec":
+                for spec_child in child.children:
+                    if spec_child.type == "type_identifier":
+                        result["name"] = self.extract_node_text(spec_child, source_code)
+                        result["type"] = "type_declaration"
+                    elif spec_child.type == "struct_type":
+                        result["type"] = "struct_declaration"
+                        for struct_child in spec_child.children:
+                            if struct_child.type == "field_declaration_list":
+                                children = []
+                                for field in struct_child.children:
+                                    field_result = process_children_callback(field)
+                                    if field_result and self._is_significant_node(
+                                        field_result
+                                    ):
+                                        children.append(field_result)
+                                if children:
+                                    result["children"] = children
+                    elif spec_child.type == "interface_type":
+                        result["type"] = "interface_declaration"
+
+        return result
+
+    def _handle_var_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        var_name = None
+        var_type = None
+
+        for child in node.children:
+            if child.type in ["var_spec", "const_spec"]:
+                for subchild in child.children:
+                    if subchild.type == "identifier" and var_name is None:
+                        var_name = self.extract_node_text(subchild, source_code)
+                    elif subchild.type in [
+                        "type_identifier",
+                        "pointer_type",
+                        "array_type",
+                        "slice_type",
+                        "map_type",
+                        "channel_type",
+                        "qualified_type",
+                    ]:
+                        var_type = self.extract_node_text(subchild, source_code)
+
+        if var_name:
+            result["type"] = "variable_declaration"
+            if var_type:
+                result["name"] = f"{var_name} {var_type}"
+            else:
+                result["name"] = var_name
+
+        return result
+
+    def _handle_field_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        field_name = None
+        field_type = None
+
+        for child in node.children:
+            if child.type == "field_identifier":
+                field_name = self.extract_node_text(child, source_code)
+            elif child.type in [
+                "type_identifier",
+                "pointer_type",
+                "array_type",
+                "slice_type",
+                "map_type",
+                "channel_type",
+                "qualified_type",
+                "struct_type",
+                "interface_type",
+            ]:
+                field_type = self.extract_node_text(child, source_code)
+
+        if field_name:
+            result["type"] = "field_declaration"
+            if field_type:
+                result["name"] = f"{field_name} {field_type}"
+            else:
+                result["name"] = field_name
+
+        return result

AgentCrew/modules/code_analysis/parsers/java_parser.py

@@ -0,0 +1,103 @@
+"""
+Java language parser for code analysis.
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class JavaParser(BaseLanguageParser):
+    """Parser for Java source code."""
+
+    @property
+    def language_name(self) -> str:
+        return "java"
+
+    def process_node(
+        self, node, source_code: bytes, process_children_callback
+    ) -> Optional[Dict[str, Any]]:
+        result = self._create_base_result(node)
+
+        if node.type in ["class_declaration", "interface_declaration"]:
+            for child in node.children:
+                if child.type == "identifier":
+                    result["name"] = self.extract_node_text(child, source_code)
+                elif child.type in ["class_body", "interface_body"]:
+                    result["children"] = [
+                        process_children_callback(c) for c in child.children
+                    ]
+
+        elif node.type == "method_declaration":
+            self._handle_method_declaration(node, source_code, result)
+
+        elif node.type == "field_declaration":
+            self._handle_field_declaration(node, source_code, result)
+
+        elif node.type == "annotation":
+            annotation_name = self.extract_node_text(node, source_code)
+            result["name"] = annotation_name
+            result["type"] = "annotation"
+
+        elif node.type == "lambda_expression":
+            result["type"] = "lambda_expression"
+
+        children = [process_children_callback(child) for child in node.children]
+        if children:
+            result["children"] = children
+
+        return result
+
+    def _handle_method_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> None:
+        method_name = None
+        parameters = []
+        return_type = None
+
+        for child in node.children:
+            if child.type == "identifier":
+                method_name = self.extract_node_text(child, source_code)
+                result["name"] = method_name
+            elif child.type == "formal_parameters":
+                for param in child.children:
+                    if param.type == "parameter":
+                        param_name = self.extract_node_text(
+                            param.child_by_field_name("name"), source_code
+                        )
+                        param_type = self.extract_node_text(
+                            param.child_by_field_name("type"), source_code
+                        )
+                        parameters.append(f"{param_type} {param_name}")
+                result["parameters"] = parameters
+            elif child.type == "type":
+                return_type = self.extract_node_text(child, source_code)
+                result["return_type"] = return_type
+
+    def _handle_field_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> None:
+        field_type = None
+        field_name = None
+
+        for child in node.children:
+            if child.type in [
+                "type_identifier",
+                "generic_type",
+                "array_type",
+                "integral_type",
+                "floating_point_type",
+                "boolean_type",
+            ]:
+                field_type = self.extract_node_text(child, source_code)
+            elif child.type == "variable_declarator":
+                name_node = child.child_by_field_name("name")
+                if name_node:
+                    field_name = self.extract_node_text(name_node, source_code)
+
+        if field_name:
+            result["type"] = "field_declaration"
+            if field_type:
+                result["name"] = f"{field_type} {field_name}"
+            else:
+                result["name"] = field_name

AgentCrew/modules/code_analysis/parsers/javascript_parser.py

@@ -0,0 +1,268 @@
+"""
+JavaScript/TypeScript language parser for code analysis.
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class JavaScriptParser(BaseLanguageParser):
+    """Parser for JavaScript and TypeScript source code."""
+
+    @property
+    def language_name(self) -> str:
+        return "javascript"
+
+    def process_node(
+        self, node, source_code: bytes, process_children_callback
+    ) -> Optional[Dict[str, Any]]:
+        result = self._create_base_result(node)
+
+        if node.type in [
+            "class_declaration",
+            "method_definition",
+            "class",
+            "method_declaration",
+            "function_declaration",
+            "interface_declaration",
+            "export_statement",
+            "arrow_function",
+            "lexical_declaration",
+        ]:
+            if node.type == "export_statement":
+                return self._handle_export_statement(
+                    node, source_code, process_children_callback
+                )
+            elif node.type == "arrow_function":
+                return self._handle_arrow_function(
+                    node, source_code, result, process_children_callback
+                )
+            elif node.type == "lexical_declaration":
+                return self._handle_lexical_declaration(
+                    node, source_code, result, process_children_callback
+                )
+            else:
+                self._handle_regular_declaration(node, source_code, result)
+
+        elif node.type in ["property_declaration", "public_field_definition"]:
+            return self._handle_property_declaration(node, source_code, result)
+
+        elif node.type in ["variable_statement", "variable_declaration"]:
+            return self._handle_variable_statement(
+                node, source_code, result, process_children_callback
+            )
+
+        children = []
+        for child in node.children:
+            child_result = process_children_callback(child)
+            if child_result and self._is_significant_node(child_result):
+                children.append(child_result)
+
+        if children:
+            result["children"] = children
+
+        return result
+
+    def _handle_export_statement(
+        self, node, source_code: bytes, process_children_callback
+    ) -> Optional[Dict[str, Any]]:
+        for child in node.children:
+            if child.type in [
+                "class_declaration",
+                "function_declaration",
+                "interface_declaration",
+                "variable_statement",
+                "lexical_declaration",
+                "method_definition",
+            ]:
+                exported_result = process_children_callback(child)
+                if exported_result:
+                    exported_result["exported"] = True
+                    return exported_result
+        return None
+
+    def _handle_arrow_function(
+        self,
+        node,
+        source_code: bytes,
+        result: Dict[str, Any],
+        process_children_callback,
+    ) -> Dict[str, Any]:
+        parent = node.parent
+        if parent and parent.type == "variable_declarator":
+            for sibling in parent.children:
+                if sibling.type == "identifier":
+                    result["type"] = "arrow_function"
+                    result["name"] = self.extract_node_text(sibling, source_code)
+
+        for child in node.children:
+            if child.type == "formal_parameters":
+                params = self._extract_parameters(child, source_code)
+                if params:
+                    result["parameters"] = params
+
+        return result
+
+    def _handle_lexical_declaration(
+        self,
+        node,
+        source_code: bytes,
+        result: Dict[str, Any],
+        process_children_callback,
+    ) -> Dict[str, Any]:
+        for child in node.children:
+            if child.type == "variable_declarator":
+                var_name = None
+                has_arrow_function = False
+
+                for declarator_child in child.children:
+                    if declarator_child.type == "identifier":
+                        var_name = self.extract_node_text(declarator_child, source_code)
+                    elif declarator_child.type == "arrow_function":
+                        has_arrow_function = True
+
+                if var_name and has_arrow_function:
+                    result["type"] = "arrow_function"
+                    result["name"] = var_name
+                    for declarator_child in child.children:
+                        if declarator_child.type == "arrow_function":
+                            arrow_result = process_children_callback(declarator_child)
+                            if arrow_result and "parameters" in arrow_result:
+                                result["parameters"] = arrow_result["parameters"]
+                else:
+                    result["type"] = "variable_declaration"
+                    result["name"] = var_name
+                    result["first_line"] = (
+                        self.extract_node_text(node, source_code)
+                        .split("\n")[0]
+                        .strip("{")
+                    )
+
+        return result
+
+    def _handle_regular_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> None:
+        for child in node.children:
+            if child.type in ["identifier", "type_identifier", "property_identifier"]:
+                result["name"] = self.extract_node_text(child, source_code)
+            elif child.type == "formal_parameters" and node.type in [
+                "function_declaration",
+                "method_declaration",
+                "method_definition",
+            ]:
+                params = self._extract_parameters_with_types(child, source_code)
+                if params:
+                    result["parameters"] = params
+
+    def _handle_variable_statement(
+        self,
+        node,
+        source_code: bytes,
+        result: Dict[str, Any],
+        process_children_callback,
+    ) -> Dict[str, Any]:
+        for child in node.children:
+            if child.type == "variable_declaration_list":
+                for declarator in child.children:
+                    if declarator.type == "variable_declarator":
+                        var_name = None
+                        has_arrow_function = False
+
+                        for declarator_child in declarator.children:
+                            if declarator_child.type == "identifier":
+                                var_name = self.extract_node_text(
+                                    declarator_child, source_code
+                                )
+                            elif declarator_child.type == "arrow_function":
+                                has_arrow_function = True
+
+                        if var_name:
+                            if has_arrow_function:
+                                result["type"] = "arrow_function"
+                                result["name"] = var_name
+                                for declarator_child in declarator.children:
+                                    if declarator_child.type == "arrow_function":
+                                        arrow_result = process_children_callback(
+                                            declarator_child
+                                        )
+                                        if (
+                                            arrow_result
+                                            and "parameters" in arrow_result
+                                        ):
+                                            result["parameters"] = arrow_result[
+                                                "parameters"
+                                            ]
+                            else:
+                                result["type"] = "variable_declaration"
+                                result["name"] = var_name
+                            return result
+
+            elif child.type == "identifier":
+                result["type"] = "variable_declaration"
+                result["name"] = self.extract_node_text(child, source_code)
+                return result
+
+        return result
+
+    def _handle_property_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        prop_name = None
+        prop_type = None
+
+        for child in node.children:
+            if child.type in ["property_identifier", "identifier"]:
+                prop_name = self.extract_node_text(child, source_code)
+            elif child.type == "type_annotation":
+                for type_child in child.children:
+                    if type_child.type != ":":
+                        prop_type = self.extract_node_text(type_child, source_code)
+
+        if prop_name:
+            result["type"] = "property_declaration"
+            if prop_type:
+                result["name"] = f"{prop_name}: {prop_type}"
+            else:
+                result["name"] = prop_name
+
+        return result
+
+    def _extract_parameters(self, params_node, source_code: bytes) -> list:
+        params = []
+        for param in params_node.children:
+            if param.type in ["required_parameter", "optional_parameter", "identifier"]:
+                param_text = self.extract_node_text(param, source_code)
+                params.append(param_text)
+        return params
+
+    def _extract_parameters_with_types(self, params_node, source_code: bytes) -> list:
+        params = []
+        for param in params_node.children:
+            if param.type in ["required_parameter", "optional_parameter", "identifier"]:
+                param_name = None
+                param_type = None
+
+                if param.type == "identifier":
+                    param_name = self.extract_node_text(param, source_code)
+                    params.append(param_name)
+                    continue
+
+                for param_child in param.children:
+                    if param_child.type in ["identifier", "object_pattern"]:
+                        param_name = self.extract_node_text(param_child, source_code)
+                    elif param_child.type == "type_annotation":
+                        for type_child in param_child.children:
+                            if type_child.type != ":":
+                                param_type = self.extract_node_text(
+                                    type_child, source_code
+                                )
+
+                if param_name:
+                    if param_type:
+                        params.append(f"{param_name}: {param_type}")
+                    else:
+                        params.append(param_name)
+
+        return params

AgentCrew/modules/code_analysis/parsers/kotlin_parser.py

@@ -0,0 +1,84 @@
+"""
+Kotlin language parser for code analysis.
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class KotlinParser(BaseLanguageParser):
+    """Parser for Kotlin source code."""
+
+    @property
+    def language_name(self) -> str:
+        return "kotlin"
+
+    def process_node(
+        self, node, source_code: bytes, process_children_callback
+    ) -> Optional[Dict[str, Any]]:
+        result = self._create_base_result(node)
+
+        if node.type == "class_declaration":
+            for child in node.children:
+                if child.type in ["simple_identifier", "type_identifier"]:
+                    result["name"] = self.extract_node_text(child, source_code)
+                elif child.type == "class_body":
+                    children = []
+                    for body_child in child.children:
+                        child_result = process_children_callback(body_child)
+                        if child_result and self._is_significant_node(child_result):
+                            children.append(child_result)
+                    if children:
+                        result["children"] = children
+            return result
+
+        elif node.type == "function_declaration":
+            for child in node.children:
+                if child.type == "simple_identifier":
+                    result["name"] = self.extract_node_text(child, source_code)
+                    return result
+            return result
+
+        elif node.type in ["property_declaration", "variable_declaration"]:
+            return self._handle_property_declaration(node, source_code, result)
+
+        children = []
+        for child in node.children:
+            child_result = process_children_callback(child)
+            if child_result and self._is_significant_node(child_result):
+                children.append(child_result)
+
+        if children:
+            result["children"] = children
+
+        return result
+
+    def _handle_property_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        prop_name = None
+        prop_type = None
+
+        for child in node.children:
+            if child.type == "variable_declaration":
+                for subchild in child.children:
+                    if subchild.type == "simple_identifier" and prop_name is None:
+                        prop_name = self.extract_node_text(subchild, source_code)
+                    elif subchild.type == "user_type":
+                        prop_type = self.extract_node_text(subchild, source_code)
+                    elif subchild.type in ["nullable_type", "type_identifier"]:
+                        prop_type = self.extract_node_text(subchild, source_code)
+            elif child.type == "simple_identifier" and prop_name is None:
+                prop_name = self.extract_node_text(child, source_code)
+            elif child.type == "user_type":
+                prop_type = self.extract_node_text(child, source_code)
+
+        if prop_name:
+            result["type"] = "property_declaration"
+            if prop_type:
+                result["name"] = f"{prop_name}: {prop_type}"
+            else:
+                result["name"] = prop_name
+
+        return result