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

AgentCrew/modules/code_analysis/parsers/php_parser.py

@@ -0,0 +1,107 @@
+"""
+PHP language parser for code analysis.
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class PhpParser(BaseLanguageParser):
+    """Parser for PHP source code."""
+
+    @property
+    def language_name(self) -> str:
+        return "php"
+
+    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",
+            "trait_declaration",
+        ]:
+            for child in node.children:
+                if child.type == "name":
+                    result["name"] = self.extract_node_text(child, source_code)
+                elif child.type == "declaration_list":
+                    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 in ["method_declaration", "function_definition"]:
+            for child in node.children:
+                if child.type == "name":
+                    result["name"] = self.extract_node_text(child, source_code)
+                    return result
+            return result
+
+        elif node.type == "property_declaration":
+            return self._handle_property_declaration(node, source_code, result)
+
+        elif node.type == "const_declaration":
+            return self._handle_const_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 in [
+                "primitive_type",
+                "named_type",
+                "optional_type",
+                "union_type",
+            ]:
+                prop_type = self.extract_node_text(child, source_code)
+            elif child.type == "property_element":
+                for subchild in child.children:
+                    if subchild.type == "variable_name":
+                        prop_name = self.extract_node_text(subchild, source_code)
+
+        if prop_name:
+            result["type"] = "property_declaration"
+            if prop_type:
+                result["name"] = f"{prop_type} {prop_name}"
+            else:
+                result["name"] = prop_name
+
+        return result
+
+    def _handle_const_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        const_name = None
+
+        for child in node.children:
+            if child.type == "const_element":
+                for subchild in child.children:
+                    if subchild.type == "name":
+                        const_name = self.extract_node_text(subchild, source_code)
+
+        if const_name:
+            result["type"] = "const_declaration"
+            result["name"] = const_name
+
+        return result

AgentCrew/modules/code_analysis/parsers/python_parser.py

@@ -0,0 +1,60 @@
+"""
+Python language parser for code analysis.
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class PythonParser(BaseLanguageParser):
+    """Parser for Python source code."""
+
+    @property
+    def language_name(self) -> str:
+        return "python"
+
+    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_definition", "function_definition"]:
+            for child in node.children:
+                if child.type == "identifier":
+                    result["name"] = self.extract_node_text(child, source_code)
+                elif child.type == "parameters":
+                    params = []
+                    for param in child.children:
+                        if "parameter" in param.type or param.type == "identifier":
+                            params.append(self.extract_node_text(param, source_code))
+                    if params:
+                        result["parameters"] = params
+
+        elif node.type == "assignment":
+            var_name = None
+            var_type = None
+            for child in node.children:
+                if child.type == "identifier" and var_name is None:
+                    var_name = self.extract_node_text(child, source_code)
+                elif child.type == "type":
+                    var_type = self.extract_node_text(child, 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
+
+        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/ruby_parser.py

@@ -0,0 +1,46 @@
+"""
+Ruby language parser for code analysis.
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class RubyParser(BaseLanguageParser):
+    """Parser for Ruby source code."""
+
+    @property
+    def language_name(self) -> str:
+        return "ruby"
+
+    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", "method", "singleton_method", "module"]:
+            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 ["assignment", "global_variable"]:
+            for child in node.children:
+                if child.type in ["identifier", "global_variable"]:
+                    result["type"] = "variable_declaration"
+                    result["name"] = self.extract_node_text(child, 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/rust_parser.py

@@ -0,0 +1,72 @@
+"""
+Rust language parser for code analysis.
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class RustParser(BaseLanguageParser):
+    """Parser for Rust source code."""
+
+    @property
+    def language_name(self) -> str:
+        return "rust"
+
+    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 ["struct_item", "impl_item", "fn_item", "trait_item"]:
+            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 ["static_item", "const_item", "let_declaration"]:
+            return self._handle_variable_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_variable_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 == "identifier" and var_name is None:
+                var_name = self.extract_node_text(child, source_code)
+            elif child.type == "pattern":
+                if child.children:
+                    var_name = self.extract_node_text(child.children[0], source_code)
+            elif child.type in [
+                "type_identifier",
+                "generic_type",
+                "reference_type",
+                "pointer_type",
+                "array_type",
+                "primitive_type",
+            ]:
+                var_type = self.extract_node_text(child, 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