quantalogic 0.60.0__py3-none-any.whl → 0.61.0__py3-none-any.whl

quantalogic/python_interpreter/operator_visitors.py

@@ -0,0 +1,108 @@
+import ast
+from typing import Any
+
+from .interpreter_core import ASTInterpreter
+
+async def visit_BinOp(self: ASTInterpreter, node: ast.BinOp, wrap_exceptions: bool = True) -> Any:
+    left: Any = await self.visit(node.left, wrap_exceptions=wrap_exceptions)
+    right: Any = await self.visit(node.right, wrap_exceptions=wrap_exceptions)
+    op = node.op
+    if isinstance(op, ast.Add):
+        return left + right
+    elif isinstance(op, ast.Sub):
+        if isinstance(left, set) and isinstance(right, set):
+            return left - right
+        return left - right
+    elif isinstance(op, ast.Mult):
+        return left * right
+    elif isinstance(op, ast.Div):
+        return left / right
+    elif isinstance(op, ast.FloorDiv):
+        return left // right
+    elif isinstance(op, ast.Mod):
+        return left % right
+    elif isinstance(op, ast.Pow):
+        return left**right
+    elif isinstance(op, ast.LShift):
+        return left << right
+    elif isinstance(op, ast.RShift):
+        return left >> right
+    elif isinstance(op, ast.BitOr):
+        if isinstance(left, set) and isinstance(right, set):
+            return left | right
+        return left | right
+    elif isinstance(op, ast.BitXor):
+        return left ^ right
+    elif isinstance(op, ast.BitAnd):
+        if isinstance(left, set) and isinstance(right, set):
+            return left & right
+        return left & right
+    else:
+        raise Exception("Unsupported binary operator: " + str(op))
+
+async def visit_UnaryOp(self: ASTInterpreter, node: ast.UnaryOp, wrap_exceptions: bool = True) -> Any:
+    operand: Any = await self.visit(node.operand, wrap_exceptions=wrap_exceptions)
+    op = node.op
+    if isinstance(op, ast.UAdd):
+        return +operand
+    elif isinstance(op, ast.USub):
+        return -operand
+    elif isinstance(op, ast.Not):
+        return not operand
+    elif isinstance(op, ast.Invert):
+        return ~operand
+    else:
+        raise Exception("Unsupported unary operator: " + str(op))
+
+async def visit_Compare(self: ASTInterpreter, node: ast.Compare, wrap_exceptions: bool = True) -> bool:
+    left: Any = await self.visit(node.left, wrap_exceptions=wrap_exceptions)
+    for op, comparator in zip(node.ops, node.comparators):
+        right: Any = await self.visit(comparator, wrap_exceptions=wrap_exceptions)
+        if isinstance(op, ast.Eq):
+            if not (left == right):
+                return False
+        elif isinstance(op, ast.NotEq):
+            if not (left != right):
+                return False
+        elif isinstance(op, ast.Lt):
+            if not (left < right):
+                return False
+        elif isinstance(op, ast.LtE):
+            if not (left <= right):
+                return False
+        elif isinstance(op, ast.Gt):
+            if not (left > right):
+                return False
+        elif isinstance(op, ast.GtE):
+            if not (left >= right):
+                return False
+        elif isinstance(op, ast.Is):
+            if left is not right:
+                return False
+        elif isinstance(op, ast.IsNot):
+            if not (left is not right):
+                return False
+        elif isinstance(op, ast.In):
+            if left not in right:
+                return False
+        elif isinstance(op, ast.NotIn):
+            if not (left not in right):
+                return False
+        else:
+            raise Exception("Unsupported comparison operator: " + str(op))
+        left = right
+    return True
+
+async def visit_BoolOp(self: ASTInterpreter, node: ast.BoolOp, wrap_exceptions: bool = True) -> bool:
+    if isinstance(node.op, ast.And):
+        for value in node.values:
+            if not await self.visit(value, wrap_exceptions=wrap_exceptions):
+                return False
+        return True
+    elif isinstance(node.op, ast.Or):
+        for value in node.values:
+            if await self.visit(value, wrap_exceptions=wrap_exceptions):
+                return True
+        return False
+    else:
+        raise Exception("Unsupported boolean operator: " + str(node.op))

quantalogic/python_interpreter/scope.py

@@ -0,0 +1,10 @@
+# quantalogic/utils/scope.py
+class Scope:
+    def __init__(self, env_stack):
+        self.env_stack = env_stack
+
+    def __enter__(self):
+        self.env_stack.append({})
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.env_stack.pop()

quantalogic/python_interpreter/visit_handlers.py

@@ -0,0 +1,110 @@
+from .base_visitors import (
+    visit_Module,
+    visit_Expr,
+    visit_Pass,
+    visit_TypeIgnore,
+)
+
+from .import_visitors import (
+    visit_Import,
+    visit_ImportFrom,
+)
+
+from .literal_visitors import (
+    visit_Constant,
+    visit_Name,
+    visit_List,
+    visit_Tuple,
+    visit_Dict,
+    visit_Set,
+    visit_Attribute,
+    visit_Subscript,
+    visit_Slice,
+    visit_Index,
+    visit_Starred,
+    visit_JoinedStr,
+    visit_FormattedValue,
+)
+
+from .operator_visitors import (
+    visit_BinOp,
+    visit_UnaryOp,
+    visit_Compare,
+    visit_BoolOp,
+)
+
+from .assignment_visitors import (
+    visit_Assign,
+    visit_AugAssign,
+    visit_AnnAssign,
+    visit_NamedExpr,
+)
+
+from .control_flow_visitors import (
+    visit_If,
+    visit_While,
+    visit_For,
+    visit_AsyncFor,
+    visit_Break,
+    visit_Continue,
+    visit_Return,
+    visit_IfExp,
+)
+
+from .function_visitors import (
+    visit_FunctionDef,
+    visit_AsyncFunctionDef,
+    visit_AsyncGeneratorDef,
+    visit_Call,
+    visit_Await,
+    visit_Lambda,
+)
+
+from .comprehension_visitors import (
+    visit_ListComp,
+    visit_DictComp,
+    visit_SetComp,
+    visit_GeneratorExp,
+)
+
+from .exception_visitors import (
+    visit_Try,
+    visit_TryStar,
+    visit_Raise,
+)
+
+from .class_visitors import (
+    visit_ClassDef,
+)
+
+from .context_visitors import (
+    visit_With,
+    visit_AsyncWith,
+)
+
+from .misc_visitors import (
+    visit_Global,
+    visit_Nonlocal,
+    visit_Delete,
+    visit_Assert,
+    visit_Yield,
+    visit_YieldFrom,
+    visit_Match,
+    _match_pattern,
+)
+
+__all__ = [
+    "visit_Import", "visit_ImportFrom", "visit_ListComp", "visit_Module", "visit_Expr",
+    "visit_Constant", "visit_Name", "visit_BinOp", "visit_UnaryOp", "visit_Assign",
+    "visit_AugAssign", "visit_AnnAssign", "visit_Compare", "visit_BoolOp", "visit_If",
+    "visit_While", "visit_For", "visit_Break", "visit_Continue", "visit_FunctionDef",
+    "visit_AsyncFunctionDef", "visit_AsyncGeneratorDef", "visit_Call", "visit_Await",
+    "visit_Return", "visit_Lambda", "visit_List", "visit_Tuple", "visit_Dict",
+    "visit_Set", "visit_Attribute", "visit_Subscript", "visit_Slice", "visit_Index",
+    "visit_Starred", "visit_Pass", "visit_TypeIgnore", "visit_Try", "visit_TryStar",
+    "visit_Nonlocal", "visit_JoinedStr", "visit_FormattedValue", "visit_GeneratorExp",
+    "visit_ClassDef", "visit_With", "visit_AsyncWith", "visit_Raise", "visit_Global",
+    "visit_IfExp", "visit_DictComp", "visit_SetComp", "visit_Yield", "visit_YieldFrom",
+    "visit_Match", "visit_Delete", "visit_AsyncFor", "visit_Assert", "visit_NamedExpr",
+    "_match_pattern",
+]

quantalogic/tools/__init__.py

@@ -8,6 +8,7 @@ from .duckduckgo_search_tool import DuckDuckGoSearchTool
 from .edit_whole_content_tool import EditWholeContentTool
 from .elixir_tool import ElixirTool
 from .execute_bash_command_tool import ExecuteBashCommandTool
+from .file_tracker_tool import FileTrackerTool
 from .grep_app_tool import GrepAppTool
 from .input_question_tool import InputQuestionTool
 from .jinja_tool import JinjaTool
@@ -22,17 +23,16 @@ from .read_file_tool import ReadFileTool
 from .read_html_tool import ReadHTMLTool
 from .replace_in_file_tool import ReplaceInFileTool
 from .ripgrep_tool import RipgrepTool
-from .safe_python_interpreter_tool import SafePythonInterpreterTool
-from .search_definition_names import SearchDefinitionNames
+from .search_definition_names_tool import SearchDefinitionNamesTool
 from .sequence_tool import SequenceTool
 from .serpapi_search_tool import SerpApiSearchTool
 from .sql_query_tool import SQLQueryTool
 from .task_complete_tool import TaskCompleteTool
 from .tool import Tool, ToolArgument, create_tool
 from .unified_diff_tool import UnifiedDiffTool
+from .utils.generate_database_report import generate_database_report
 from .wikipedia_search_tool import WikipediaSearchTool
 from .write_file_tool import WriteFileTool
-from .file_tracker_tool import FileTrackerTool
 
 # Define __all__ to control what gets imported with `from quantalogic.tools import *`
 __all__ = [
@@ -42,6 +42,7 @@ __all__ = [
     'EditWholeContentTool',
     'ElixirTool',
     'ExecuteBashCommandTool',
+    'generate_database_report',
     'GrepAppTool',
     'InputQuestionTool',
     'JinjaTool',
@@ -57,7 +58,7 @@ __all__ = [
     'ReplaceInFileTool',
     'RipgrepTool',
     'SafePythonInterpreterTool',
-    'SearchDefinitionNames',
+    'SearchDefinitionNamesTool',
     'SequenceTool',
     'SerpApiSearchTool',
     'SQLQueryTool',

quantalogic/tools/action_gen.py

@@ -0,0 +1,366 @@
+import ast
+import asyncio
+from asyncio import TimeoutError
+from contextlib import AsyncExitStack
+from functools import partial
+from typing import Callable, Dict, List
+
+import litellm
+import typer
+from loguru import logger
+
+from quantalogic.python_interpreter import execute_async
+from quantalogic.tools.tool import Tool, ToolArgument
+
+# Configure loguru to log to a file with rotation, matching original
+logger.add("action_gen.log", rotation="10 MB", level="DEBUG")
+
+# Initialize Typer app, unchanged
+app = typer.Typer()
+
+# Define tool classes with logging in async_execute, preserving original structure
+class AddTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="add_tool",
+            description="Adds two numbers and returns the sum.",
+            arguments=[
+                ToolArgument(name="a", arg_type="int", description="First number", required=True),
+                ToolArgument(name="b", arg_type="int", description="Second number", required=True)
+            ],
+            return_type="int"
+        )
+    
+    async def async_execute(self, **kwargs) -> str:
+        logger.info(f"Starting tool execution: {self.name}")
+        logger.info(f"Adding {kwargs['a']} and {kwargs['b']}")
+        result = str(int(kwargs["a"]) + int(kwargs["b"]))
+        logger.info(f"Finished tool execution: {self.name}")
+        return result
+
+class MultiplyTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="multiply_tool",
+            description="Multiplies two numbers and returns the product.",
+            arguments=[
+                ToolArgument(name="x", arg_type="int", description="First number", required=True),
+                ToolArgument(name="y", arg_type="int", description="Second number", required=True)
+            ],
+            return_type="int"
+        )
+    
+    async def async_execute(self, **kwargs) -> str:
+        logger.info(f"Starting tool execution: {self.name}")
+        logger.info(f"Multiplying {kwargs['x']} and {kwargs['y']}")
+        result = str(int(kwargs["x"]) * int(kwargs["y"]))
+        logger.info(f"Finished tool execution: {self.name}")
+        return result
+
+class ConcatTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="concat_tool",
+            description="Concatenates two strings.",
+            arguments=[
+                ToolArgument(name="s1", arg_type="string", description="First string", required=True),
+                ToolArgument(name="s2", arg_type="string", description="Second string", required=True)
+            ],
+            return_type="string"
+        )
+    
+    async def async_execute(self, **kwargs) -> str:
+        logger.info(f"Starting tool execution: {self.name}")
+        logger.info(f"Concatenating '{kwargs['s1']}' and '{kwargs['s2']}'")
+        result = kwargs["s1"] + kwargs["s2"]
+        logger.info(f"Finished tool execution: {self.name}")
+        return result
+
+class AgentTool(Tool):
+    def __init__(self, model: str = "gemini/gemini-2.0-flash"):
+        super().__init__(
+            name="agent_tool",
+            description="Generates text using a language model based on a system prompt and user prompt.",
+            arguments=[
+                ToolArgument(name="system_prompt", arg_type="string", description="System prompt to guide the model's behavior", required=True),
+                ToolArgument(name="prompt", arg_type="string", description="User prompt to generate a response for", required=True),
+                ToolArgument(name="temperature", arg_type="float", description="Temperature for generation (0 to 1)", required=True)
+            ],
+            return_type="string"
+        )
+        self.model = model
+    
+    async def async_execute(self, **kwargs) -> str:
+        logger.info(f"Starting tool execution: {self.name}")
+        system_prompt = kwargs["system_prompt"]
+        prompt = kwargs["prompt"]
+        temperature = float(kwargs["temperature"])
+        
+        # Validate temperature, unchanged
+        if not 0 <= temperature <= 1:
+            logger.error(f"Temperature {temperature} is out of range (0-1)")
+            raise ValueError("Temperature must be between 0 and 1")
+        
+        logger.info(f"Generating text with model {self.model}, temperature {temperature}")
+        try:
+            async with AsyncExitStack() as stack:
+                timeout_cm = asyncio.timeout(30)
+                await stack.enter_async_context(timeout_cm)
+                
+                logger.debug(f"Making API call to {self.model}")
+                response = await litellm.acompletion(
+                    model=self.model,
+                    messages=[
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": prompt}
+                    ],
+                    temperature=temperature,
+                    max_tokens=1000  # Original default
+                )
+                generated_text = response.choices[0].message.content.strip()
+                logger.debug(f"Generated text: {generated_text}")
+                result = generated_text
+                logger.info(f"Finished tool execution: {self.name}")
+                return result
+        except TimeoutError as e:
+            error_msg = f"API call to {self.model} timed out after 30 seconds"
+            logger.error(error_msg)
+            raise TimeoutError(error_msg) from e
+        except Exception as e:
+            logger.error(f"Failed to generate text with {self.model}: {str(e)}")
+            raise RuntimeError(f"Text generation failed: {str(e)}")
+
+# Asynchronous function to generate the program, matching original behavior with updated prompt
+async def generate_program(task_description: str, tools: List[Tool], model: str, max_tokens: int) -> str:
+    """
+    Asynchronously generate a Python program that solves a given task using a list of tools.
+
+    Args:
+        task_description (str): A description of the task to be solved.
+        tools (List[Tool]): A list of Tool objects available for use.
+        model (str): The litellm model to use for code generation.
+        max_tokens (int): Maximum number of tokens for the generated response.
+
+    Returns:
+        str: A string containing a complete Python program.
+    """
+    logger.debug(f"Generating program for task: {task_description}")
+    tool_docstrings = "\n\n".join([tool.to_docstring() for tool in tools])
+
+    # Updated prompt with reinforced instruction to exclude __main__ block
+    prompt = f"""
+You are a Python code generator. Your task is to create a Python program that solves the following task:
+"{task_description}"
+
+You have access to the following pre-defined async tool functions, as defined with their signatures and descriptions:
+
+{tool_docstrings}
+
+Instructions:
+1. Generate a Python program as a single string.
+2. Include only the import for asyncio (import asyncio).
+3. Define an async function named main() that solves the task.
+4. Use the pre-defined tool functions (e.g., add_tool, multiply_tool, concat_tool) directly by calling them with await and the appropriate arguments as specified in their descriptions.
+5. Do not redefine the tool functions within the program; assume they are already available in the namespace.
+6. Return the program as markdown code block.
+7. Strictly exclude asyncio.run(main()) or any code outside the main() function definition, including any 'if __name__ == "__main__":' block, as the runtime will handle execution of main().
+8. Do not include explanatory text outside the program string.
+9. Express all string variables as multiline strings
+string, always start a string at the beginning of a line.
+10. Always print the result at the end of the program.
+
+Example task: "Add 5 and 7 and print the result"
+Example output:
+```python
+import asyncio
+
+async def main():
+    result = await add_tool(a=5, b=7)
+    print(result)
+```
+"""
+    
+    logger.debug(f"Prompt sent to litellm:\n{prompt}")
+    
+    try:
+        logger.debug(f"Calling litellm with model {model}")
+        response = await litellm.acompletion(
+            model=model,
+            messages=[
+                {"role": "system", "content": "You are a Python code generator."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=max_tokens,
+            temperature=0.3
+        )
+        generated_code = response.choices[0].message.content.strip()
+        logger.debug("Code generation successful")
+    except Exception as e:
+        logger.error(f"Failed to generate code: {str(e)}")
+        raise typer.BadParameter(f"Failed to generate code with model '{model}': {str(e)}")
+
+    # Clean up output, preserving original logic
+    if generated_code.startswith('"""') and generated_code.endswith('"""'):
+        generated_code = generated_code[3:-3]
+    elif generated_code.startswith("```python") and generated_code.endswith("```"):
+        generated_code = generated_code[9:-3].strip()
+    
+    # Post-processing to remove any __main__ block if generated despite instructions
+    if "if __name__ == \"__main__\":" in generated_code:
+        lines = generated_code.splitlines()
+        main_end_idx = next(
+            (i for i in range(len(lines)) if "if __name__" in lines[i]),
+            len(lines)
+        )
+        generated_code = "\n".join(lines[:main_end_idx]).strip()
+        logger.warning("Removed unexpected __main__ block from generated code")
+
+    return generated_code
+
+# Updated async core logic with improved interpreter usage
+async def generate_core(task: str, model: str, max_tokens: int) -> None:
+    """
+    Core logic to generate and execute a Python program based on a task description.
+
+    Args:
+        task (str): The task description to generate a program for.
+        model (str): The litellm model to use for generation.
+        max_tokens (int): Maximum number of tokens for the generated response.
+    """
+    logger.info(f"Starting generate command for task: {task}")
+    # Input validation, unchanged
+    if not task.strip():
+        logger.error("Task description is empty")
+        raise typer.BadParameter("Task description cannot be empty")
+    if max_tokens <= 0:
+        logger.error("max-tokens must be positive")
+        raise typer.BadParameter("max-tokens must be a positive integer")
+
+    # Initialize tools, unchanged
+    tools = [
+        AddTool(),
+        MultiplyTool(),
+        ConcatTool(),
+        AgentTool(model=model)
+    ]
+
+    # Generate the program
+    try:
+        program = await generate_program(task, tools, model, max_tokens)
+    except Exception as e:
+        logger.error(f"Failed to generate program: {str(e)}")
+        typer.echo(typer.style(f"Error: {str(e)}", fg=typer.colors.RED))
+        raise typer.Exit(code=1)
+
+    logger.debug(f"Generated program:\n{program}")
+    # Output the generated program with original style
+    typer.echo(typer.style("Generated Python Program:", fg=typer.colors.GREEN, bold=True))
+    typer.echo(program)
+    
+    # Validate program structure
+    try:
+        ast_tree = ast.parse(program)
+        has_async_main = any(
+            isinstance(node, ast.AsyncFunctionDef) and node.name == "main"
+            for node in ast.walk(ast_tree)
+        )
+        if not has_async_main:
+            logger.warning("Generated code lacks an async main() function")
+            typer.echo(typer.style("Warning: Generated code lacks an async main() function", fg=typer.colors.YELLOW))
+            return
+    except SyntaxError as e:
+        logger.error(f"Syntax error in generated code: {str(e)}")
+        typer.echo(typer.style(f"Syntax error in generated code: {str(e)}", fg=typer.colors.RED))
+        return
+
+    # Prepare namespace with tool instances
+    namespace: Dict[str, Callable] = {
+        "asyncio": asyncio,
+        "add_tool": partial(AddTool().async_execute),
+        "multiply_tool": partial(MultiplyTool().async_execute),
+        "concat_tool": partial(ConcatTool().async_execute),
+        "agent_tool": partial(AgentTool(model=model).async_execute),
+    }
+
+    # Check for namespace collisions
+    reserved_names = set(vars(__builtins__))
+    for name in namespace:
+        if name in reserved_names and name != "asyncio":
+            logger.warning(f"Namespace collision detected: '{name}' shadows a builtin")
+            typer.echo(typer.style(f"Warning: Tool name '{name}' shadows a builtin", fg=typer.colors.YELLOW))
+
+    # Execute the program
+    typer.echo("\n" + typer.style("Executing the program:", fg=typer.colors.GREEN, bold=True))
+    try:
+        logger.debug("Executing generated code with execute_async")
+        execution_result = await execute_async(
+            code=program,
+            timeout=30,
+            entry_point="main",
+            allowed_modules=["asyncio"],
+            namespace=namespace,
+        )
+        
+        # Detailed error handling
+        if execution_result.error:
+            if "SyntaxError" in execution_result.error:
+                logger.error(f"Syntax error: {execution_result.error}")
+                typer.echo(typer.style(f"Syntax error: {execution_result.error}", fg=typer.colors.RED))
+            elif "TimeoutError" in execution_result.error:
+                logger.error(f"Timeout: {execution_result.error}")
+                typer.echo(typer.style(f"Timeout: {execution_result.error}", fg=typer.colors.RED))
+            else:
+                logger.error(f"Runtime error: {execution_result.error}")
+                typer.echo(typer.style(f"Runtime error: {execution_result.error}", fg=typer.colors.RED))
+        else:
+            logger.info(f"Execution completed in {execution_result.execution_time:.2f} seconds")
+            typer.echo(typer.style(f"Execution completed in {execution_result.execution_time:.2f} seconds", fg=typer.colors.GREEN))
+            
+            # Display the result if it's not None
+            if execution_result.result is not None:
+                typer.echo("\n" + typer.style("Result:", fg=typer.colors.BLUE, bold=True))
+                typer.echo(str(execution_result.result))
+    except ValueError as e:
+        logger.error(f"Invalid code generated: {str(e)}")
+        typer.echo(typer.style(f"Invalid code: {str(e)}", fg=typer.colors.RED))
+    except Exception as e:
+        logger.error(f"Unexpected execution error: {str(e)}")
+        typer.echo(typer.style(f"Unexpected error during execution: {str(e)}", fg=typer.colors.RED))
+    else:
+        logger.info("Program executed successfully")
+
+@app.command()
+def generate(
+    task: str = typer.Argument(
+        ...,
+        help="The task description to generate a program for (e.g., 'Add 5 and 7 and print the result')"
+    ),
+    model: str = typer.Option(
+        "gemini/gemini-2.0-flash",
+        "--model",
+        "-m",
+        help="The litellm model to use for generation (e.g., 'gpt-3.5-turbo', 'gpt-4')"
+    ),
+    max_tokens: int = typer.Option(
+        4000,
+        "--max-tokens",
+        "-t",
+        help="Maximum number of tokens for the generated response (default: 4000)"
+    )
+) -> None:
+    """Generate and execute a Python program based on a task description"""
+    try:
+        # Run async core logic, preserving original execution style
+        asyncio.run(generate_core(task, model, max_tokens))
+    except Exception as e:
+        logger.error(f"Command failed: {str(e)}")
+        typer.echo(typer.style(f"Error: {str(e)}", fg=typer.colors.RED))
+        raise typer.Exit(code=1)
+
+# Entry point, unchanged
+def main() -> None:
+    logger.debug("Starting script execution")
+    app()
+
+if __name__ == "__main__":
+    main()

quantalogic/tools/python_tool.py

@@ -154,6 +154,10 @@ class PythonTool(Tool):
             script_path = os.path.join(temp_dir, "script.py")
             self._write_script(script_path, script)
 
+            # Ensure the host directory exists
+            if host_dir:
+                self._ensure_directory_exists(host_dir)
+
             # Prepare pip install commands
             pip_install_cmd = self._prepare_install_commands(install_commands)
 
@@ -417,6 +421,15 @@ class PythonTool(Tool):
         logger.debug(f"Parsed environment variables: {env_vars}")
         return env_vars
 
+    def _ensure_directory_exists(self, directory_path: str) -> None:
+        """Ensures the specified directory exists, creating it if it does not.
+
+        Args:
+            directory_path (str): The path to the directory to ensure.
+        """
+        if not os.path.exists(directory_path):
+            os.makedirs(directory_path)
+
 
 if __name__ == "__main__":
     # Example usage of PythonTool

quantalogic/tools/{search_definition_names.py → search_definition_names_tool.py}

@@ -24,7 +24,7 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-class SearchDefinitionNames(Tool):
+class SearchDefinitionNamesTool(Tool):
     """Tool for searching definition names in a directory using Tree-sitter.
 
     Supports searching for:
@@ -448,7 +448,7 @@ class SearchDefinitionNames(Tool):
 
 
 if __name__ == "__main__":
-    tool = SearchDefinitionNames()
+    tool = SearchDefinitionNamesTool()
     print(tool.to_markdown())
 
     # Example usage with different output formats