quantalogic 0.2.0__py3-none-any.whl

quantalogic/tools/elixir_tool.py

@@ -0,0 +1,240 @@
+"""Tool to execute Elixir code in an isolated Docker environment with Mix project support."""
+
+import logging
+import os
+import subprocess
+import tempfile
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class ElixirTool(Tool):
+    """Tool to execute Elixir code in an isolated Docker environment with Mix project support."""
+
+    name: str = "elixir_tool"
+    description: str = (
+        "Executes Elixir code within a Docker container using Mix for package management.\n\n"
+        "FEATURES:\n"
+        "- Full Mix project support with dependency management\n"
+        "- Isolated Docker environment execution\n"
+        "- Configurable Elixir versions\n"
+        "- Environment variable support\n"
+        "- Host directory mounting\n"
+        "- Memory limit configuration\n\n"
+        "EXECUTION ENVIRONMENT:\n"
+        "- Runs in an isolated Docker container\n"
+        "- Uses official Elixir Docker images\n"
+        "- Supports Mix package manager\n"
+        "- Full access to standard library\n\n"
+        "ACCEPTED OUTPUT METHODS:\n"
+        "- IO.puts/1, IO.write/1\n"
+        "- Logger module\n"
+        "- File operations when host_dir mounted\n\n"
+        "EXAMPLE:\n"
+        'defmodule Example do\n  def hello, do: IO.puts("Hello from Elixir!")\nend\n\nExample.hello()'
+    )
+
+    arguments: list[ToolArgument] = [
+        ToolArgument(
+            name="mix_commands",
+            arg_type="string",
+            description="Mix commands to run before executing script",
+            required=False,
+            example="mix deps.get && mix compile",
+        ),
+        ToolArgument(
+            name="script",
+            arg_type="string",
+            description="Elixir code to execute",
+            required=True,
+            example='IO.puts("Hello!")',
+        ),
+        ToolArgument(
+            name="version",
+            arg_type="string",
+            description="Elixir version to use",
+            required=False,
+            default="1.15",
+        ),
+        ToolArgument(
+            name="host_dir",
+            arg_type="string",
+            description="Host directory to mount",
+            required=False,
+        ),
+        ToolArgument(
+            name="memory_limit",
+            arg_type="string",
+            description="Container memory limit",
+            required=False,
+            example="512m",
+        ),
+        ToolArgument(
+            name="environment_vars",
+            arg_type="string",
+            description="Environment variables (KEY=VALUE)",
+            required=False,
+            example="MIX_ENV=prod",
+        ),
+    ]
+
+    def check_docker(self) -> None:
+        """Verify Docker is installed and accessible."""
+        try:
+            subprocess.run(
+                ["docker", "--version"],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            raise RuntimeError("Docker is not installed or not accessible") from e
+
+    def validate_version(self, version: str) -> None:
+        """Validate Elixir version is supported."""
+        valid_versions = ["1.14", "1.15", "1.16"]
+        if version not in valid_versions:
+            raise ValueError(f"Unsupported Elixir version '{version}'. Valid versions: {', '.join(valid_versions)}")
+
+    def write_script(self, script_path: str, script: str) -> None:
+        """Write Elixir script to file."""
+        if not script.strip():
+            raise ValueError("Script content cannot be empty")
+
+        # Always wrap in ElixirScript module
+        wrapped_script = r"""
+defmodule ElixirScript do
+  def main do
+    try do
+      %s
+    rescue
+      error -> 
+        formatted = Exception.format(:error, error, __STACKTRACE__)
+        IO.puts("Error: #{formatted}")
+        System.halt(1)
+    end
+  end
+end
+
+# Execute the main function
+ElixirScript.main()
+""" % script.strip()
+
+        with open(script_path, "w", encoding="utf-8") as f:
+            f.write(wrapped_script.strip())
+
+    def execute(
+        self,
+        script: str,
+        mix_commands: str | None = None,
+        version: str = "1.15",
+        host_dir: str | None = None,
+        memory_limit: str | None = None,
+        environment_vars: str | None = None,
+    ) -> str:
+        """Execute Elixir code in Docker container with Mix support."""
+        # Validate inputs
+        self.check_docker()
+        self.validate_version(version)
+
+        docker_image = f"elixir:{version}-slim"
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Write script directly without Mix project
+            script_path = os.path.join(temp_dir, "script.exs")
+            self.write_script(script_path, script)
+
+            # Prepare Docker command
+            cmd = ["docker", "run", "--rm"]
+
+            # Add memory limit
+            if memory_limit:
+                cmd.extend(["--memory", memory_limit])
+
+            # Mount directories
+            cmd.extend(["-v", f"{temp_dir}:/app"])
+            cmd.extend(["-w", "/app"])
+
+            if host_dir:
+                cmd.extend(["-v", f"{host_dir}:/host"])
+
+            # Add environment variables
+            if environment_vars:
+                for pair in environment_vars.split():
+                    if "=" in pair:
+                        cmd.extend(["-e", pair])
+
+            # Add image and command to run the script directly
+            cmd.extend([docker_image, "elixir", "script.exs"])
+
+            # Execute
+            try:
+                result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+                output = result.stdout
+                if result.stderr:
+                    output = f"{output}\nErrors:\n{result.stderr}"
+                return output.strip()
+            except subprocess.CalledProcessError as e:
+                error_msg = e.stderr if e.stderr else e.stdout
+                raise RuntimeError(f"Execution failed: {error_msg}")
+
+
+def main():
+    """Run example Elixir code executions."""
+    tool = ElixirTool()
+
+    print("\nExample 1: Simple Output")
+    simple_script = r"""
+    IO.puts("Starting simple output test...")
+    IO.puts("Hello from Elixir!")
+    IO.puts("Simple output test completed.")
+    """
+    print(tool.execute(script=simple_script))
+
+    print("\nExample 2: Basic Module")
+    module_script = r"""
+    IO.puts("Starting calculator module test...")
+    
+    defmodule Calculator do
+      def add(a, b) do
+        IO.puts("Calculating #{a} + #{b}...")
+        result = a + b
+        IO.puts("Result: #{a} + #{b} = #{result}")
+        result
+      end
+    end
+
+    IO.puts("\nTesting Calculator.add(5, 3):")
+    result = Calculator.add(5, 3)
+    IO.puts("Calculator test completed. Final result: #{result}")
+    """
+    print(tool.execute(script=module_script))
+
+    print("\nExample 3: Binary Encoding")
+    json_script = r"""
+    IO.puts("Starting binary encoding test...")
+    
+    IO.puts("Ensuring applications are started...")
+    {:ok, _} = Application.ensure_all_started(:inets)
+    {:ok, _} = Application.ensure_all_started(:ssl)
+    
+    IO.puts("\nPreparing test data...")
+    data = %{name: "John", age: 30}
+    IO.puts("Data: #{inspect(data)}")
+    
+    IO.puts("\nEncoding data...")
+    encoded = :erlang.term_to_binary(data) 
+             |> Base.encode64()
+    IO.puts("Encoded result: #{encoded}")
+    
+    IO.puts("\nBinary encoding test completed.")
+    """
+    print(tool.execute(script=json_script))
+
+
+if __name__ == "__main__":
+    main()

quantalogic/tools/execute_bash_command_tool.py

@@ -0,0 +1,116 @@
+"""Tool for executing bash commands and capturing their output."""
+
+import os
+import subprocess
+from typing import Dict, Optional, Union
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class ExecuteBashCommandTool(Tool):
+    """Tool for executing bash commands and capturing their output."""
+
+    name: str = "execute_bash_tool"
+    description: str = "Executes a bash command and returns its output."
+    need_validation: bool = True
+    arguments: list = [
+        ToolArgument(
+            name="command",
+            arg_type="string",
+            description="The bash command to execute.",
+            required=True,
+            example="ls -la",
+        ),
+        ToolArgument(
+            name="working_dir",
+            arg_type="string",
+            description="The working directory where the command will be executed. Defaults to the current directory.",
+            required=False,
+            example="/path/to/directory",
+        ),
+        ToolArgument(
+            name="timeout",
+            arg_type="int",
+            description="Maximum time in seconds to wait for the command to complete. Defaults to 60 seconds.",
+            required=False,
+            example="60",
+        ),
+        # Removed the `env` argument from ToolArgument since it doesn't support `dict` type
+    ]
+
+    def execute(
+        self,
+        command: str,
+        working_dir: Optional[str] = None,
+        timeout: Union[int, str, None] = 60,
+        env: Optional[Dict[str, str]] = None,
+    ) -> str:
+        """Executes a bash command and returns its output.
+
+        Args:
+            command (str): The bash command to execute.
+            working_dir (str, optional): Working directory for command execution. Defaults to the current directory.
+            timeout (int or str, optional): Maximum execution time in seconds. Defaults to 60 seconds.
+            env (dict, optional): Environment variables to set for the command execution. Defaults to the current environment.
+
+        Returns:
+            str: The command output or error message.
+
+        Raises:
+            subprocess.TimeoutExpired: If the command execution exceeds the timeout.
+            subprocess.CalledProcessError: If the command returns a non-zero exit status.
+            ValueError: If the timeout cannot be converted to an integer.
+        """
+        # Convert timeout to integer, defaulting to 60 if None or invalid
+        try:
+            timeout_seconds = int(timeout) if timeout else 60
+        except (ValueError, TypeError):
+            timeout_seconds = 60
+
+        # Use the current working directory if no working directory is specified
+        cwd = working_dir if working_dir else os.getcwd()
+
+        # Use the current environment if no custom environment is specified
+        env_vars = os.environ.copy()
+        if env:
+            env_vars.update(env)
+
+        try:
+            # Execute the command with specified timeout, working directory, and environment
+            result = subprocess.run(
+                command,
+                shell=True,
+                cwd=cwd,
+                capture_output=True,
+                text=True,
+                timeout=timeout_seconds,
+                env=env_vars,
+            )
+
+            formated_result = (
+                "<command_output>"
+                f" <stdout>"
+                f"{result.stdout.strip()}"
+                f" </stdout>"
+                f" <stderr>"
+                f"{result.stderr.strip()}"
+                f" </stderr>"
+                f" <returncode>"
+                f" {result.returncode}"
+                f" </returncode>"
+                f"</command_output>"
+            )
+
+            return formated_result
+
+        except subprocess.TimeoutExpired:
+            return f"Command timed out after {timeout_seconds} seconds."
+        except subprocess.CalledProcessError as e:
+            return f"Command failed with error: {e.stderr.strip()}"
+        except Exception as e:
+            return f"Unexpected error executing command: {str(e)}"
+
+
+if __name__ == "__main__":
+    tool = ExecuteBashCommandTool()
+    print(tool.to_markdown())

quantalogic/tools/input_question_tool.py

@@ -0,0 +1,57 @@
+"""Tool for prompting the user with a question and capturing their input."""
+
+from loguru import logger
+from rich.prompt import Prompt
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class InputQuestionTool(Tool):
+    """Tool to prompt the user with a question and capture their input."""
+
+    name: str = "input_question_tool"
+    description: str = "Prompts the user with a question and captures their input."
+    arguments: list = [
+        ToolArgument(
+            name="question",
+            arg_type="string",
+            description="The question to ask the user.",
+            required=True,
+            example="What is your favorite color?",
+        ),
+        ToolArgument(
+            name="default",
+            arg_type="string",
+            description="Optional default value if no input is provided.",
+            required=False,
+            example="blue",
+        ),
+    ]
+
+    def execute(self, question: str, default: str | None = None) -> str:
+        """Prompts the user with a question and captures their input.
+
+        Args:
+            question (str): The question to ask the user.
+            default (str | None, optional): Optional default value. Defaults to None.
+
+        Returns:
+            str: The user's input or the default value.
+        """
+        try:
+            # Use rich.prompt to create an interactive prompt
+            user_input = Prompt.ask(question, default=default)
+
+            # Log the input for debugging purposes
+            logger.debug(f"User input for question '{question}': {user_input}")
+
+            return user_input
+        except Exception as e:
+            # Log any errors that occur during input
+            logger.error(f"Error in input_question tool: {e}")
+            raise
+
+
+if __name__ == "__main__":
+    tool = InputQuestionTool()
+    print(tool.to_markdown())

quantalogic/tools/language_handlers/__init__.py

@@ -0,0 +1,21 @@
+from .c_handler import CLanguageHandler
+from .cpp_handler import CppLanguageHandler
+from .go_handler import GoLanguageHandler
+from .java_handler import JavaLanguageHandler
+from .javascript_handler import JavaScriptLanguageHandler
+from .python_handler import PythonLanguageHandler
+from .rust_handler import RustLanguageHandler
+from .scala_handler import ScalaLanguageHandler
+from .typescript_handler import TypeScriptLanguageHandler
+
+__all__ = [
+    "CLanguageHandler",
+    "CppLanguageHandler",
+    "GoLanguageHandler",
+    "JavaLanguageHandler",
+    "JavaScriptLanguageHandler",
+    "PythonLanguageHandler",
+    "RustLanguageHandler",
+    "ScalaLanguageHandler",
+    "TypeScriptLanguageHandler",
+]

quantalogic/tools/language_handlers/c_handler.py

@@ -0,0 +1,33 @@
+import tree_sitter_c as tsc
+from tree_sitter import Language
+
+
+class CLanguageHandler:
+    """Handler for C-specific language processing."""
+
+    def get_language(self):
+        """Returns the Tree-sitter Language object for C."""
+        return Language(tsc.language())
+
+    def validate_root_node(self, root_node):
+        """Validates the root node for C syntax trees."""
+        return root_node.type == "translation_unit"
+
+    def process_node(
+        self, node, current_class, definitions, process_method, process_function, process_class, process_class_variable
+    ):
+        """Processes a node in a C syntax tree."""
+        if node.type == "function_definition":
+            if current_class:
+                process_method(node, definitions["classes"][current_class]["methods"])
+            else:
+                process_function(node, definitions["functions"])
+            return "function"
+        elif node.type == "struct_specifier":
+            class_name = process_class(node)
+            definitions["classes"][class_name] = {
+                "line": (node.start_point[0] + 1, node.end_point[0] + 1),
+                "methods": [],
+                "variables": [],
+            }
+            return "class"

quantalogic/tools/language_handlers/cpp_handler.py

@@ -0,0 +1,33 @@
+import tree_sitter_cpp as tscpp
+from tree_sitter import Language
+
+
+class CppLanguageHandler:
+    """Handler for C++-specific language processing."""
+
+    def get_language(self):
+        """Returns the Tree-sitter Language object for C++."""
+        return Language(tscpp.language())
+
+    def validate_root_node(self, root_node):
+        """Validates the root node for C++ syntax trees."""
+        return root_node.type == "translation_unit"
+
+    def process_node(
+        self, node, current_class, definitions, process_method, process_function, process_class, process_class_variable
+    ):
+        """Processes a node in a C++ syntax tree."""
+        if node.type == "function_definition":
+            if current_class:
+                process_method(node, definitions["classes"][current_class]["methods"])
+            else:
+                process_function(node, definitions["functions"])
+            return "function"
+        elif node.type == "class_specifier":
+            class_name = process_class(node)
+            definitions["classes"][class_name] = {
+                "line": (node.start_point[0] + 1, node.end_point[0] + 1),
+                "methods": [],
+                "variables": [],
+            }
+            return "class"

quantalogic/tools/language_handlers/go_handler.py

@@ -0,0 +1,33 @@
+import tree_sitter_go as tsgo
+from tree_sitter import Language
+
+
+class GoLanguageHandler:
+    """Handler for Go-specific language processing."""
+
+    def get_language(self):
+        """Returns the Tree-sitter Language object for Go."""
+        return Language(tsgo.language())
+
+    def validate_root_node(self, root_node):
+        """Validates the root node for Go syntax trees."""
+        return root_node.type == "source_file"
+
+    def process_node(
+        self, node, current_class, definitions, process_method, process_function, process_class, process_class_variable
+    ):
+        """Processes a node in a Go syntax tree."""
+        if node.type == "function_declaration":
+            if current_class:
+                process_method(node, definitions["classes"][current_class]["methods"])
+            else:
+                process_function(node, definitions["functions"])
+            return "function"
+        elif node.type == "type_declaration":
+            class_name = process_class(node)
+            definitions["classes"][class_name] = {
+                "line": (node.start_point[0] + 1, node.end_point[0] + 1),
+                "methods": [],
+                "variables": [],
+            }
+            return "class"

quantalogic/tools/language_handlers/java_handler.py

@@ -0,0 +1,37 @@
+import tree_sitter_java as tsjava
+from tree_sitter import Language
+
+
+class JavaLanguageHandler:
+    """Handler for Java-specific language processing."""
+
+    def get_language(self):
+        """Returns the Tree-sitter Language object for Java."""
+        return Language(tsjava.language())
+
+    def validate_root_node(self, root_node):
+        """Validates the root node for Java syntax trees."""
+        return root_node.type == "program"
+
+    def process_node(
+        self, node, current_class, definitions, process_method, process_function, process_class, process_class_variable
+    ):
+        """Processes a node in a Java syntax tree."""
+        if node.type == "method_declaration":
+            if current_class:
+                process_method(node, definitions["classes"][current_class]["methods"])
+            else:
+                process_function(node, definitions["functions"])
+            return "method"
+        elif node.type == "class_declaration":
+            class_name = process_class(node)
+            definitions["classes"][class_name] = {
+                "line": (node.start_point[0] + 1, node.end_point[0] + 1),
+                "methods": [],
+                "variables": [],
+            }
+            return "class"
+        elif node.type == "field_declaration":
+            if current_class:
+                process_class_variable(node, definitions["classes"][current_class]["variables"])
+            return "variable"

quantalogic/tools/language_handlers/javascript_handler.py

@@ -0,0 +1,42 @@
+import tree_sitter_javascript as tsjavascript
+from tree_sitter import Language
+
+
+class JavaScriptLanguageHandler:
+    """Handler for JavaScript-specific language processing."""
+
+    def get_language(self):
+        """Returns the Tree-sitter Language object for JavaScript."""
+        return Language(tsjavascript.language())
+
+    def validate_root_node(self, root_node):
+        """Validates the root node for JavaScript syntax trees."""
+        return root_node.type == "program"
+
+    def process_node(
+        self, node, current_class, definitions, process_method, process_function, process_class, process_class_variable
+    ):
+        """Processes a node in a JavaScript syntax tree."""
+        if node.type in ("function_declaration", "method_definition"):
+            if current_class:
+                process_method(node, definitions["classes"][current_class]["methods"])
+            else:
+                process_function(node, definitions["functions"])
+            return "function"
+        elif node.type == "class_declaration":
+            class_name = process_class(node)
+            definitions["classes"][class_name] = {
+                "line": (node.start_point[0] + 1, node.end_point[0] + 1),
+                "methods": [],
+                "variables": [],
+            }
+            return "class"
+        elif node.type == "method_definition":
+            if current_class:
+                process_method(node, definitions["classes"][current_class]["methods"])
+            return "method"
+        elif node.type == "field_definition":
+            if current_class:
+                process_class_variable(node, definitions["classes"][current_class]["variables"])
+            return "variable"
+        return None

quantalogic/tools/language_handlers/python_handler.py

@@ -0,0 +1,29 @@
+import tree_sitter_python as tspython
+from tree_sitter import Language
+
+
+class PythonLanguageHandler:
+    """Handler for Python-specific language processing."""
+
+    def get_language(self):
+        """Returns the Tree-sitter Language object for Python."""
+        return Language(tspython.language())
+
+    def validate_root_node(self, root_node):
+        """Validates the root node for Python syntax trees."""
+        return root_node.type == "module"
+
+    def process_node(
+        self, node, current_class, definitions, process_method, process_function, process_class, process_class_variable
+    ):
+        """Processes a node in a Python syntax tree."""
+        if node.type in ("function_definition", "async_function_definition"):
+            if current_class:
+                process_method(node, definitions["classes"][current_class]["methods"])
+            else:
+                process_function(node, definitions["functions"])
+            return "function"
+        elif node.type == "class_definition":
+            class_name, start_line, end_line = process_class(node)
+            definitions["classes"][class_name] = {"line": (start_line, end_line), "methods": [], "variables": []}
+            return "class"

quantalogic/tools/language_handlers/rust_handler.py

@@ -0,0 +1,33 @@
+import tree_sitter_rust as tsrust
+from tree_sitter import Language
+
+
+class RustLanguageHandler:
+    """Handler for Rust-specific language processing."""
+
+    def get_language(self):
+        """Returns the Tree-sitter Language object for Rust."""
+        return Language(tsrust.language())
+
+    def validate_root_node(self, root_node):
+        """Validates the root node for Rust syntax trees."""
+        return root_node.type == "source_file"
+
+    def process_node(
+        self, node, current_class, definitions, process_method, process_function, process_class, process_class_variable
+    ):
+        """Processes a node in a Rust syntax tree."""
+        if node.type == "function_item":
+            if current_class:
+                process_method(node, definitions["classes"][current_class]["methods"])
+            else:
+                process_function(node, definitions["functions"])
+            return "function"
+        elif node.type == "struct_item":
+            class_name = process_class(node)
+            definitions["classes"][class_name] = {
+                "line": (node.start_point[0] + 1, node.end_point[0] + 1),
+                "methods": [],
+                "variables": [],
+            }
+            return "class"