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

AgentCrew/modules/code_analysis/parsers/csharp_parser.py

@@ -0,0 +1,162 @@
+"""
+C# language parser for code analysis.
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class CSharpParser(BaseLanguageParser):
+    """Parser for C# source code."""
+
+    @property
+    def language_name(self) -> str:
+        return "c-sharp"
+
+    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":
+            self._handle_class_declaration(node, source_code, result)
+
+        elif node.type == "method_declaration":
+            self._handle_method_declaration(node, source_code, result)
+
+        elif node.type == "property_declaration":
+            self._handle_property_declaration(node, source_code, result)
+
+        elif node.type == "field_declaration":
+            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_class_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> None:
+        for child in node.children:
+            if child.type == "identifier":
+                result["name"] = self.extract_node_text(child, source_code)
+            elif child.type == "base_list":
+                if len(child.children) > 1:
+                    result["base_class"] = self.extract_node_text(
+                        child.children[1], source_code
+                    )
+
+    def _handle_method_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> None:
+        method_name = None
+        parameters = []
+        access_modifiers = []
+
+        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 == "parameter_list":
+                for param in child.children:
+                    if param.type == "parameter":
+                        param_type = ""
+                        param_name = None
+
+                        type_node = param.child_by_field_name("type")
+                        name_node = param.child_by_field_name("name")
+
+                        if type_node:
+                            param_type = self.extract_node_text(type_node, source_code)
+                        if name_node:
+                            param_name = self.extract_node_text(name_node, source_code)
+
+                        if param_name:
+                            parameters.append(param_type + " " + param_name)
+
+                if parameters:
+                    result["parameters"] = parameters
+            elif child.type == "modifier":
+                modifier = self.extract_node_text(child, source_code)
+                access_modifiers.append(modifier)
+
+        if access_modifiers:
+            result["modifiers"] = access_modifiers
+
+    def _handle_property_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> None:
+        property_name = None
+        property_type = None
+        modifiers = []
+
+        for child in node.children:
+            if child.type == "modifier":
+                modifiers.append(self.extract_node_text(child, source_code))
+            elif child.type in [
+                "predefined_type",
+                "nullable_type",
+                "generic_name",
+                "array_type",
+            ]:
+                property_type = self.extract_node_text(child, source_code)
+            elif child.type == "identifier":
+                if property_type is None:
+                    property_type = self.extract_node_text(child, source_code)
+                else:
+                    property_name = self.extract_node_text(child, source_code)
+
+        if property_name:
+            result["type"] = "property_declaration"
+            if property_type:
+                result["name"] = f"{property_type} {property_name}"
+            else:
+                result["name"] = property_name
+            if modifiers:
+                result["modifiers"] = modifiers
+
+    def _handle_field_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> None:
+        field_name = None
+        field_type = None
+        modifiers = []
+
+        for child in node.children:
+            if child.type == "modifier":
+                modifiers.append(self.extract_node_text(child, source_code))
+            elif child.type == "variable_declaration":
+                for subchild in child.children:
+                    if subchild.type in [
+                        "predefined_type",
+                        "nullable_type",
+                        "generic_name",
+                        "array_type",
+                    ]:
+                        field_type = self.extract_node_text(subchild, source_code)
+                    elif subchild.type == "identifier" and field_type is None:
+                        field_type = self.extract_node_text(subchild, source_code)
+                    elif subchild.type == "variable_declarator":
+                        for var_child in subchild.children:
+                            if var_child.type == "identifier":
+                                field_name = self.extract_node_text(
+                                    var_child, source_code
+                                )
+                                break
+
+        if field_name:
+            result["type"] = "field_declaration"
+            if field_type:
+                result["name"] = f"{field_type} {field_name}"
+            else:
+                result["name"] = field_name
+            if modifiers:
+                result["modifiers"] = modifiers

AgentCrew/modules/code_analysis/parsers/generic_parser.py

@@ -0,0 +1,63 @@
+"""
+Generic language parser for code analysis (fallback for unsupported languages).
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class GenericParser(BaseLanguageParser):
+    """Generic parser for languages without specific implementation."""
+
+    def __init__(self, language: str = "unknown"):
+        self._language = language
+
+    @property
+    def language_name(self) -> str:
+        return self._language
+
+    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 [
+            "type_declaration",
+            "function_declaration",
+            "method_declaration",
+            "interface_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 in ["var_declaration", "const_declaration"]:
+            for child in node.children:
+                if child.type in ["var_spec", "const_spec"]:
+                    for subchild in child.children:
+                        if subchild.type == "identifier":
+                            result["type"] = "variable_declaration"
+                            result["name"] = self.extract_node_text(
+                                subchild, source_code
+                            )
+                            return result
+            return 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

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