agentic-radar 0.1.2__py3-none-any.whl

agentic_radar/__init__.py

@@ -0,0 +1,3 @@
+import importlib.metadata
+
+__version__ = importlib.metadata.version("agentic_radar")

agentic_radar/__main__.py

@@ -0,0 +1,3 @@
+from .cli import app
+
+app(prog_name="agentic-radar")

agentic_radar/analysis/__init__.py

@@ -0,0 +1,3 @@
+from .langgraph import LangGraphAnalyzer
+
+__all__ = ["LangGraphAnalyzer"]

agentic_radar/analysis/analyze.py

@@ -0,0 +1,8 @@
+import abc
+
+from ..graph import GraphDefinition
+
+
+class Analyzer(abc.ABC):
+    def analyze(self, root_directory: str) -> GraphDefinition:
+        raise NotImplementedError()

agentic_radar/analysis/langgraph/__init__.py

@@ -0,0 +1,3 @@
+from .analyze import LangGraphAnalyzer
+
+__all__ = ["LangGraphAnalyzer"]

agentic_radar/analysis/langgraph/analyze.py

@@ -0,0 +1,148 @@
+from pathlib import Path
+
+from ...analysis.analyze import Analyzer
+from ...graph import EdgeDefinition as Edge
+from ...graph import GraphDefinition
+from ...graph import NodeDefinition as Node
+from ...graph import NodeType, ToolType
+from .custom_tools import get_all_custom_tools_from_directory
+from .graph import parse_all_graph_instances_in_directory
+from .predefined_tools import get_all_predefined_tools_from_directory
+from .utils import build_global_registry
+
+GRAPH_CLASS = "langgraph.graph.StateGraph"
+COMMAND_CLASS = "langgraph.types.Command"
+ADD_CONDITIONAL_EDGES_METHOD_NAME = "add_conditional_edges"
+ADD_NODE_METHOD_NAME = "add_node"
+
+
+class LangGraphAnalyzer(Analyzer):
+    def __init__(self):
+        super().__init__()
+
+    def analyze(self, root_directory: str) -> GraphDefinition:
+        global_functions, global_variables = build_global_registry(root_directory)
+
+        predefined_tools = get_all_predefined_tools_from_directory(root_directory)
+
+        custom_tools = get_all_custom_tools_from_directory(root_directory)
+
+        all_graphs = parse_all_graph_instances_in_directory(
+            root_directory,
+            GRAPH_CLASS,
+            COMMAND_CLASS,
+            ADD_CONDITIONAL_EDGES_METHOD_NAME,
+            ADD_NODE_METHOD_NAME,
+            global_functions,
+            global_variables,
+        )
+        nodes = []
+        edges = []
+
+        for graph in all_graphs:
+            for i, node in enumerate(graph["graph_info"]["nodes"]):
+
+                nodes.append(
+                    Node(type=NodeType.BASIC, name=node["name"], label=node["name"])
+                )
+
+            nodes.append(Node(type=NodeType.BASIC, name="START", label="START"))
+
+            nodes.append(Node(type=NodeType.BASIC, name="END", label="END"))
+
+            for basic_edge in graph["graph_info"]["basic_edges"]:
+                edges.append(
+                    Edge(start=basic_edge["start_node"], end=basic_edge["end_node"])
+                )
+
+            for conditional_edge in graph["graph_info"]["conditional_edges"]:
+                edges.append(
+                    Edge(
+                        start=conditional_edge["start_node"],
+                        end=conditional_edge["end_node"],
+                        condition="if else",
+                    )
+                )
+
+        tools = []
+
+        for predefined_tool in predefined_tools:
+            tools.append(
+                Node(
+                    name=predefined_tool["name"],
+                    type=NodeType.TOOL,
+                    category=predefined_tool["category"],
+                    vulnerabilities=[],  # TODO Add vulnerability mapping
+                )
+            )
+
+        for custom_tool in custom_tools:
+            tools.append(
+                Node(
+                    name=custom_tool["name"],
+                    description=custom_tool["description"],
+                    type=NodeType.CUSTOM_TOOL,
+                    category=ToolType.DEFAULT,
+                    vulnerabilities=[],  # TODO Add vulnerability mapping
+                )
+            )
+
+        # This is for report generation testing
+        # tools = [
+        #     Node(
+        #         name="create_issue",
+        #         type=NodeType.TOOL,
+        #         category=ToolType.CODE_INTERPRETER,
+        #         description="Tool description",
+        #         vulnerabilities=[
+        #             VulnerabilityDefinition(
+        #                 name="Improper Output Handling",
+        #                 description="Generated",
+        #                 security_framework_mapping={
+        #                     "CVE": "blabla",
+        #                     "OWASP LLM TOP 10": "blabla",
+        #                 },
+        #                 remediation="Remediate placholder",
+        #             ),
+        #             VulnerabilityDefinition(
+        #                 name="Improper Output Handling 2",
+        #                 description="Generated",
+        #                 security_framework_mapping={
+        #                     "CVE": "blabla",
+        #                     "OWASP LLM TOP 10": "blabla",
+        #                 },
+        #                 remediation="Placeholder",
+        #             ),
+        #         ],
+        #     ),
+        #     Node(
+        #         name="create_issue 2",
+        #         type=NodeType.TOOL,
+        #         category=ToolType.CODE_INTERPRETER,
+        #         description="Tool description",
+        #         vulnerabilities=[
+        #             VulnerabilityDefinition(
+        #                 name="Improper Output Handling",
+        #                 description="Generated",
+        #                 security_framework_mapping={
+        #                     "CVE": '<span style="color: black; font-size: 10px; font-family: Inter; font-weight: 400; text-decoration: underline; line-height: 15px; word-wrap: break-word">CVE-2023-44467</span>',
+        #                     "OWASP LLM TOP 10": "blabla",
+        #                 },
+        #                 remediation="Remediate placholder",
+        #             ),
+        #             VulnerabilityDefinition(
+        #                 name="Improper Output Handling 2",
+        #                 description="Generated",
+        #                 security_framework_mapping={
+        #                     "CVE": "blabla",
+        #                     "OWASP LLM TOP 10": "blabla",
+        #                 },
+        #                 remediation="Placeholder",
+        #             ),
+        #         ],
+        #     ),
+        # ]
+
+        return GraphDefinition(
+            name=Path(root_directory).name, nodes=nodes, edges=edges, tools=tools
+        )

agentic_radar/analysis/langgraph/custom_tools.py

@@ -0,0 +1,44 @@
+import ast
+import os
+from typing import Dict, List
+
+
+def extract_custom_tools_with_ast(
+    file_content: str, file_path: str
+) -> List[Dict[str, str]]:
+    custom_tools = []
+    tree = ast.parse(file_content)
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            decorator_names = []
+            for decorator in node.decorator_list:
+                if isinstance(decorator, ast.Name):
+                    decorator_names.append(decorator.id)
+                elif isinstance(decorator, ast.Call):
+                    if isinstance(decorator.func, ast.Name):
+                        decorator_names.append(decorator.func.id)
+                    elif isinstance(decorator.func, ast.Attribute):
+                        decorator_names.append(decorator.func.attr)
+
+            if "tool" in decorator_names:
+                custom_tools.append({"name": node.name, "filepath": file_path, "description": ast.get_docstring(node)})
+
+    return custom_tools
+
+
+def get_all_custom_tools_from_directory(directory_path: str) -> List[Dict[str, str]]:
+    all_custom_tools = []
+    for root, _, files in os.walk(directory_path):
+        for file in files:
+            if file.endswith(".py"):
+                file_path = os.path.join(root, file)
+                with open(file_path, "r", encoding="utf-8") as f:
+                    file_content = f.read()
+                    custom_tools = extract_custom_tools_with_ast(
+                        file_content, file_path
+                    )
+                    for single_custom_tool in custom_tools:
+                        all_custom_tools.append(single_custom_tool)
+
+    return all_custom_tools