skydeckai-code 0.1.23__py3-none-any.whl

aidd/tools/code_execution.py

@@ -0,0 +1,321 @@
+import os
+import stat
+import subprocess
+from typing import Any, Dict, List
+
+import mcp.types as types
+
+from .state import state
+
+# Language configurations
+LANGUAGE_CONFIGS = {
+    'python': {
+        'file_extension': '.py',
+        'command': ['python3'],
+        'comment_prefix': '#'
+    },
+    'javascript': {
+        'file_extension': '.js',
+        'command': ['node'],
+        'comment_prefix': '//'
+    },
+    'ruby': {
+        'file_extension': '.rb',
+        'command': ['ruby'],
+        'comment_prefix': '#'
+    },
+    'php': {
+        'file_extension': '.php',
+        'command': ['php'],
+        'comment_prefix': '//'
+    },
+    'go': {
+        'file_extension': '.go',
+        'command': ['go', 'run'],
+        'comment_prefix': '//',
+        'wrapper_start': 'package main\nfunc main() {',
+        'wrapper_end': '}'
+    },
+    'rust': {
+        'file_extension': '.rs',
+        'command': ['rustc', '-o'],  # Special handling needed
+        'comment_prefix': '//',
+        'wrapper_start': 'fn main() {',
+        'wrapper_end': '}'
+    }
+}
+
+def execute_code_tool() -> Dict[str, Any]:
+    return {
+        "name": "execute_code",
+        "description": (
+            "Execute arbitrary code in various programming languages on the user's local machine within the current working directory. "
+            "WHEN TO USE: When you need to run small code snippets to test functionality, compute values, process data, or "
+            "demonstrate how code works. Useful for quick prototyping, data transformations, or explaining programming concepts with running "
+            "examples. "
+            "WHEN NOT TO USE: When you need to modify files (use write_file or edit_file instead), when running potentially harmful "
+            "operations, or when you need to install external dependencies. "
+            "RETURNS: Text output including stdout, stderr, and exit code of the "
+            "execution. The output sections are clearly labeled with '=== stdout ===' and '=== stderr ==='. "
+            "Supported languages: " + ", ".join(LANGUAGE_CONFIGS.keys()) + ". "
+            "Always review the code carefully before execution to prevent unintended consequences. "
+            "Examples: "
+            "- Python: code='print(sum(range(10)))'. "
+            "- JavaScript: code='console.log(Array.from({length: 5}, (_, i) => i*2))'. "
+            "- Ruby: code='puts (1..5).reduce(:+)'. "
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "language": {
+                    "type": "string",
+                    "enum": list(LANGUAGE_CONFIGS.keys()),
+                    "description": "Programming language to use. Must be one of the supported languages: " + ", ".join(LANGUAGE_CONFIGS.keys()) + ". " +
+                    "Each language requires the appropriate runtime to be installed on the user's machine. The code will be executed using: python3 for " +
+                    "Python, node for JavaScript, ruby for Ruby, php for PHP, go run for Go, and rustc for Rust."
+                },
+                "code": {
+                    "type": "string",
+                    "description": "Code to execute on the user's local machine in the current working directory. The code will be saved to a " +
+                    "temporary file and executed within the allowed workspace. For Go and Rust, main function wrappers will be added automatically if " +
+                    "not present. For PHP, <?php will be prepended if not present."
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Maximum execution time in seconds. The execution will be terminated if it exceeds this time limit, returning a " +
+                    "timeout message. Must be between 1 and 30 seconds.",
+                    "default": 5,
+                    "minimum": 1,
+                    "maximum": 30
+                }
+            },
+            "required": ["language", "code"]
+        }
+    }
+
+def execute_shell_script_tool() -> Dict[str, Any]:
+    return {
+        "name": "execute_shell_script",
+        "description": (
+            "Execute a shell script (bash/sh) on the user's local machine within the current working directory. "
+            "WHEN TO USE: When you need to automate system tasks, run shell commands, interact with the operating system, or perform operations "
+            "that are best expressed as shell commands. Useful for file system operations, system configuration, or running system utilities. "
+            "WHEN NOT TO USE: When you need more structured programming (use execute_code instead), when you need to execute potentially "
+            "dangerous system operations, or when you want to run commands outside the allowed directory. "
+            "RETURNS: Text output including stdout, stderr, and exit code of the execution. The output sections are clearly labeled with "
+            "'=== stdout ===' and '=== stderr ==='. "
+            "This tool can execute shell commands and scripts for system automation and management tasks. "
+            "It is designed to perform tasks on the user's local environment, such as opening applications, installing packages and more. "
+            "Always review the script carefully before execution to prevent unintended consequences. "
+            "Examples: "
+            "- script='echo \"Current directory:\" && pwd'. "
+            "- script='for i in {1..5}; do echo $i; done'. "
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "script": {
+                    "type": "string",
+                    "description": "Shell script to execute on the user's local machine. Can include any valid shell commands or scripts that would "
+                    "run in a standard shell environment. The script is executed using /bin/sh for maximum compatibility across systems."
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Maximum execution time in seconds. The execution will be terminated if it exceeds this time limit. "
+                    "Default is 300 seconds (5 minutes), with a maximum allowed value of 600 seconds (10 minutes).",
+                    "default": 300,
+                    "maximum": 600
+                }
+            },
+            "required": ["script"]
+        }
+    }
+
+def is_command_available(command: str) -> bool:
+    """Check if a command is available in the system."""
+    try:
+        subprocess.run(['which', command],
+                     stdout=subprocess.PIPE,
+                     stderr=subprocess.PIPE,
+                     check=True)
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+def prepare_code(code: str, language: str) -> str:
+    """Prepare code for execution based on language requirements."""
+    config = LANGUAGE_CONFIGS[language]
+
+    if language == 'go':
+        if 'package main' not in code and 'func main()' not in code:
+            return f"{config['wrapper_start']}\n{code}\n{config['wrapper_end']}"
+    elif language == 'rust':
+        if 'fn main()' not in code:
+            return f"{config['wrapper_start']}\n{code}\n{config['wrapper_end']}"
+    elif language == 'php':
+        if '<?php' not in code:
+            return f"<?php\n{code}"
+
+    return code
+
+async def execute_code_in_temp_file(language: str, code: str, timeout: int) -> tuple[str, str, int]:
+    """Execute code in a temporary file and return stdout, stderr, and return code."""
+    config = LANGUAGE_CONFIGS[language]
+    temp_file = f"temp_script{config['file_extension']}"
+
+    try:
+        # Change to allowed directory first
+        os.chdir(state.allowed_directory)
+
+        # Write code to temp file
+        with open(temp_file, 'w') as f:
+            # Prepare and write code
+            prepared_code = prepare_code(code, language)
+            f.write(prepared_code)
+            f.flush()
+
+            # Prepare command
+            if language == 'rust':
+                # Special handling for Rust
+                output_path = 'temp_script.exe'
+                compile_cmd = ['rustc', temp_file, '-o', output_path]
+                try:
+                    subprocess.run(compile_cmd,
+                                 check=True,
+                                 capture_output=True,
+                                 timeout=timeout)
+                    cmd = [output_path]
+                except subprocess.CalledProcessError as e:
+                    return '', e.stderr.decode(), e.returncode
+            else:
+                cmd = config['command'] + [temp_file]
+
+            # Execute code
+            try:
+                result = subprocess.run(
+                    cmd,
+                    capture_output=True,
+                    timeout=timeout,
+                    text=True,
+                )
+                return result.stdout, result.stderr, result.returncode
+            except subprocess.TimeoutExpired:
+                return '', f'Execution timed out after {timeout} seconds', 124
+
+    finally:
+        # Cleanup
+        # Note: We stay in the allowed directory as all operations should happen there
+        try:
+            os.unlink(temp_file)
+            if language == 'rust' and os.path.exists(output_path):
+                os.unlink(output_path)
+        except Exception:
+            pass
+
+async def handle_execute_code(arguments: dict) -> List[types.TextContent]:
+    """Handle code execution in various programming languages."""
+    language = arguments.get("language")
+    code = arguments.get("code")
+    timeout = arguments.get("timeout", 5)
+
+    if not language or not code:
+        raise ValueError("Both language and code must be provided")
+
+    if language not in LANGUAGE_CONFIGS:
+        raise ValueError(f"Unsupported language: {language}")
+
+    # Check if required command is available
+    command = LANGUAGE_CONFIGS[language]['command'][0]
+    if not is_command_available(command):
+        return [types.TextContent(
+            type="text",
+            text=f"Error: {command} is not installed on the system"
+        )]
+
+    try:
+        stdout, stderr, returncode = await execute_code_in_temp_file(language, code, timeout)
+
+        result = []
+        if stdout:
+            result.append(f"=== stdout ===\n{stdout.rstrip()}")
+        if stderr:
+            result.append(f"=== stderr ===\n{stderr.rstrip()}")
+        if not stdout and not stderr:
+            result.append("Code executed successfully with no output")
+        if returncode != 0:
+            result.append(f"\nProcess exited with code {returncode}")
+
+        return [types.TextContent(
+            type="text",
+            text="\n\n".join(result)
+        )]
+
+    except Exception as e:
+        return [types.TextContent(
+            type="text",
+            text=f"Error executing code:\n{str(e)}"
+        )]
+
+async def execute_shell_script_in_temp_file(script: str, timeout: int) -> tuple[str, str, int]:
+    """Execute a shell script in a temporary file and return stdout, stderr, and return code."""
+    temp_file = "temp_script.sh"
+
+    try:
+        # Change to allowed directory first
+        os.chdir(state.allowed_directory)
+
+        # Write script to temp file
+        with open(temp_file, 'w') as f:
+            f.write("#!/bin/sh\n")  # Use sh for maximum compatibility
+            f.write(script)
+            f.flush()
+
+        # Make the script executable
+        os.chmod(temp_file, os.stat(temp_file).st_mode | stat.S_IEXEC)
+
+        # Execute script
+        try:
+            result = subprocess.run(
+                ["/bin/sh", temp_file],  # Use sh explicitly for consistent behavior
+                capture_output=True,
+                timeout=timeout,
+                text=True,
+            )
+            return result.stdout, result.stderr, result.returncode
+        except subprocess.TimeoutExpired:
+            return '', f'Execution timed out after {timeout} seconds', 124
+
+    finally:
+        # Cleanup
+        try:
+            os.unlink(temp_file)
+        except Exception:
+            pass
+
+async def handle_execute_shell_script(arguments: dict) -> List[types.TextContent]:
+    """Handle shell script execution."""
+    script = arguments.get("script")
+    timeout = min(arguments.get("timeout", 300), 600)  # Default 5 minutes, cap at 10 minutes
+
+    try:
+        stdout, stderr, returncode = await execute_shell_script_in_temp_file(script, timeout)
+        result = []
+        if stdout:
+            result.append(f"=== stdout ===\n{stdout.rstrip()}")
+        if stderr:
+            result.append(f"=== stderr ===\n{stderr.rstrip()}")
+        if not stdout and not stderr:
+            result.append("Script executed successfully with no output")
+        if returncode != 0:
+            result.append(f"\nScript exited with code {returncode}")
+
+        return [types.TextContent(
+            type="text",
+            text="\n\n".join(result)
+        )]
+
+    except Exception as e:
+        return [types.TextContent(
+            type="text",
+            text=f"Error executing shell script:\n{str(e)}"
+        )]

aidd/tools/directory_tools.py

@@ -0,0 +1,289 @@
+import json
+import os
+import subprocess
+from datetime import datetime
+
+from mcp.types import TextContent
+
+from .state import state
+
+
+def list_directory_tool():
+    return {
+        "name": "list_directory",
+        "description": "Get a detailed listing of files and directories in the specified path, including type, size, and modification "
+                    "date. WHEN TO USE: When you need to explore the contents of a directory, understand what files are available, check file sizes or "
+                    "modification dates, or locate specific files by name. WHEN NOT TO USE: When you need to read the contents of files (use read_file "
+                    "instead), when you need a recursive listing of all subdirectories (use directory_tree instead), or when searching for files by name pattern "
+                    "(use search_files instead). RETURNS: Text with each line containing file type ([DIR]/[FILE]), name, size (in B/KB/MB), and "
+                    "modification date. Only works within the allowed directory. Example: Enter 'src' to list contents of the src directory, or '.' for "
+                    "current directory.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "Path of the directory to list. Examples: '.' for current directory, 'src' for src directory, 'docs/images' for a nested directory. The path must be within the allowed workspace.",
+                }
+            },
+            "required": ["path"]
+        },
+    }
+
+async def handle_list_directory(arguments: dict):
+    from mcp.types import TextContent
+
+    path = arguments.get("path", ".")
+
+    # Determine full path based on whether input is absolute or relative
+    if os.path.isabs(path):
+        full_path = os.path.abspath(path)  # Just normalize the absolute path
+    else:
+        # For relative paths, join with allowed_directory
+        full_path = os.path.abspath(os.path.join(state.allowed_directory, path))
+
+    if not full_path.startswith(state.allowed_directory):
+        raise ValueError(f"Access denied: Path ({full_path}) must be within allowed directory ({state.allowed_directory})")
+    if not os.path.exists(full_path):
+        raise ValueError(f"Path does not exist: {full_path}")
+    if not os.path.isdir(full_path):
+        raise ValueError(f"Path is not a directory: {full_path}")
+
+    # List directory contents
+    entries = []
+    try:
+        with os.scandir(full_path) as it:
+            for entry in it:
+                try:
+                    stat = entry.stat()
+                    # Format size to be human readable
+                    size = stat.st_size
+                    if size >= 1024 * 1024:  # MB
+                        size_str = f"{size / (1024 * 1024):.1f}MB"
+                    elif size >= 1024:  # KB
+                        size_str = f"{size / 1024:.1f}KB"
+                    else:  # bytes
+                        size_str = f"{size}B"
+
+                    entry_type = "[DIR]" if entry.is_dir() else "[FILE]"
+                    mod_time = datetime.fromtimestamp(stat.st_mtime).strftime("%Y-%m-%d %H:%M:%S")
+                    entries.append(f"{entry_type} {entry.name:<30} {size_str:>8} {mod_time}")
+                except (OSError, PermissionError):
+                    continue
+
+        entries.sort()  # Sort entries alphabetically
+        return [TextContent(type="text", text="\n".join(entries))]
+
+    except PermissionError:
+        raise ValueError(f"Permission denied accessing: {full_path}")
+
+def create_directory_tool():
+    return {
+        "name": "create_directory",
+        "description": "Create a new directory or ensure a directory exists. "
+                    "Can create multiple nested directories in one operation. "
+                    "WHEN TO USE: When you need to set up project structure, organize files, create output directories before saving files, or establish a directory hierarchy. "
+                    "WHEN NOT TO USE: When you only want to check if a directory exists (use get_file_info instead), or when trying to create directories outside the allowed workspace. "
+                    "RETURNS: Text message confirming either that the directory was successfully created or that it already exists. "
+                    "The operation succeeds silently if the directory already exists. "
+                    "Only works within the allowed directory. "
+                    "Example: Enter 'src/components' to create nested directories.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "Path of the directory to create. Can include nested directories which will all be created. Examples: 'logs' for a simple directory, 'src/components/buttons' for nested directories. Both absolute and relative paths are supported, but must be within the allowed workspace."
+                }
+            },
+            "required": ["path"]
+        },
+    }
+
+async def handle_create_directory(arguments: dict):
+    """Handle creating a new directory."""
+    from mcp.types import TextContent
+
+    path = arguments.get("path")
+    if not path:
+        raise ValueError("path must be provided")
+
+    # Determine full path based on whether input is absolute or relative
+    if os.path.isabs(path):
+        full_path = os.path.abspath(path)  # Just normalize the absolute path
+    else:
+        # For relative paths, join with allowed_directory
+        full_path = os.path.abspath(os.path.join(state.allowed_directory, path))
+
+    # Security check: ensure path is within allowed directory
+    if not full_path.startswith(state.allowed_directory):
+        raise ValueError(
+            f"Access denied: Path ({full_path}) must be within allowed directory ({state.allowed_directory})"
+        )
+
+    already_exists = os.path.exists(full_path)
+
+    try:
+        # Create directory and any necessary parent directories
+        os.makedirs(full_path, exist_ok=True)
+
+        if already_exists:
+            return [TextContent(type="text", text=f"Directory already exists: {path}")]
+        return [TextContent(
+            type="text",
+            text=f"Successfully created directory: {path}"
+        )]
+    except PermissionError:
+        raise ValueError(f"Permission denied creating directory: {path}")
+    except Exception as e:
+        raise ValueError(f"Error creating directory: {str(e)}")
+
+def directory_tree_tool():
+    return {
+        "name": "directory_tree",
+        "description": "Get a recursive tree view of files and directories in the specified path as a JSON structure. "
+                    "WHEN TO USE: When you need to understand the complete structure of a directory tree, visualize the hierarchy of files and directories, or get a comprehensive overview of a project's organization. "
+                    "Particularly useful for large projects where you need to see nested relationships. "
+                    "WHEN NOT TO USE: When you only need a flat list of files in a single directory (use directory_listing instead), or when you're only interested in specific file types (use search_files instead). "
+                    "RETURNS: JSON structure where each entry includes 'name', 'type' (file/directory), and 'children' for directories. "
+                    "Files have no children array, while directories always have a children array (which may be empty). "
+                    "The output is formatted with 2-space indentation for readability. For Git repositories, shows tracked files only. "
+                    "Only works within the allowed directory. "
+                    "Example: Enter '.' for current directory, or 'src' for a specific directory.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "Root directory to analyze. This is the starting point for the recursive tree generation. Examples: '.' for current directory, 'src' for the src directory. Both absolute and relative paths are supported, but must be within the allowed workspace."
+                }
+            },
+            "required": ["path"]
+        },
+    }
+
+async def build_directory_tree(dir_path: str) -> dict:
+    """Build directory tree as a JSON structure."""
+    try:
+        entries = list(os.scandir(dir_path))
+        # Sort entries by name
+        entries.sort(key=lambda e: e.name.lower())
+
+        result = {
+            "name": os.path.basename(dir_path) or dir_path,
+            "type": "directory",
+            "children": []
+        }
+
+        for entry in entries:
+            if entry.is_dir():
+                # Recursively process subdirectories
+                child_tree = await build_directory_tree(entry.path)
+                result["children"].append(child_tree)
+            else:
+                result["children"].append({
+                    "name": entry.name,
+                    "type": "file"
+                })
+
+        return result
+    except PermissionError:
+        raise ValueError(f"Access denied: {dir_path}")
+    except Exception as e:
+        raise ValueError(f"Error processing directory {dir_path}: {str(e)}")
+
+async def handle_directory_tree(arguments: dict):
+    """Handle building a directory tree."""
+    path = arguments.get("path", ".")
+
+    # Validate and get full path
+    full_path = os.path.abspath(os.path.join(state.allowed_directory, path))
+    if not os.path.abspath(full_path).startswith(state.allowed_directory):
+        raise ValueError(f"Access denied: Path ({full_path}) must be within allowed directory ({state.allowed_directory})")
+    if not os.path.exists(full_path):
+        raise ValueError(f"Path does not exist: {full_path}")
+    if not os.path.isdir(full_path):
+        raise ValueError(f"Path is not a directory: {full_path}")
+
+    # Try git ls-files first
+    try:
+        # Get list of all files tracked by git
+        result = subprocess.run(
+            ['git', 'ls-files'],
+            cwd=full_path,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        # If git command was successful
+        files = [f for f in result.stdout.split('\n') if f.strip()]
+        files.sort()
+
+        # Build tree from git files
+        directory_map = {}
+        root_name = os.path.basename(full_path) or full_path
+
+        # First pass: collect all directories and files
+        for file in files:
+            parts = file.split(os.sep)
+            # Add all intermediate directories
+            for i in range(len(parts)):
+                parent = os.sep.join(parts[:i])
+                os.sep.join(parts[:i+1])
+                if i < len(parts) - 1:  # It's a directory
+                    directory_map.setdefault(parent, {"dirs": set(), "files": set()})["dirs"].add(parts[i])
+                else:  # It's a file
+                    directory_map.setdefault(parent, {"dirs": set(), "files": set()})["files"].add(parts[i])
+
+        async def build_git_tree(current_path: str) -> dict:
+            dir_name = current_path.split(os.sep)[-1] if current_path else ''
+            result = {
+                "name": dir_name or root_name,
+                "type": "directory",
+                "children": [],
+            }
+
+            if current_path not in directory_map:
+                return result
+
+            entry = directory_map[current_path]
+
+            # Add directories first
+            for dir_name in sorted(entry["dirs"]):
+                child_path = os.path.join(current_path, dir_name) if current_path else dir_name
+                child_tree = await build_git_tree(child_path)
+                result["children"].append(child_tree)
+
+            # Then add files
+            for file_name in sorted(entry["files"]):
+                result["children"].append({
+                    "name": file_name,
+                    "type": "file",
+                })
+
+            return result
+
+        # Build the tree structure starting from root
+        tree = await build_git_tree('')
+        return [TextContent(type="text", text=json.dumps(tree, indent=2))]
+
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        # Git not available or not a git repository, use fallback implementation
+        pass
+    except Exception as e:
+        # Log the error but continue with fallback
+        print(f"Error using git ls-files: {e}")
+        pass
+
+    # Fallback to regular directory traversal
+    try:
+        # Build the directory tree structure
+        tree = await build_directory_tree(full_path)
+
+        # Convert to JSON with pretty printing
+        json_tree = json.dumps(tree, indent=2)
+
+        return [TextContent(type="text", text=json_tree)]
+    except Exception as e:
+        raise ValueError(f"Error building directory tree: {str(e)}")