skydeckai-code 0.1.38__tar.gz → 0.1.39__tar.gz

{skydeckai_code-0.1.38 → skydeckai_code-0.1.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skydeckai-code
-Version: 0.1.38
+Version: 0.1.39
 Summary: This MCP server provides a comprehensive set of tools for AI-driven Development workflows including file operations, code analysis, multi-language execution, web content fetching with HTML-to-markdown conversion, multi-engine web search, code content searching, and system information retrieval.
 Project-URL: Homepage, https://github.com/skydeckai/skydeckai-code
 Project-URL: Repository, https://github.com/skydeckai/skydeckai-code

{skydeckai_code-0.1.38 → skydeckai_code-0.1.39}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "skydeckai-code"
-version = "0.1.38"
+version = "0.1.39"
 description = "This MCP server provides a comprehensive set of tools for AI-driven Development workflows including file operations, code analysis, multi-language execution, web content fetching with HTML-to-markdown conversion, multi-engine web search, code content searching, and system information retrieval."
 readme = "README.md"
 requires-python = ">=3.11"

{skydeckai_code-0.1.38 → skydeckai_code-0.1.39}/src/aidd/tools/code_execution.py

@@ -2,49 +2,28 @@ import os
 import stat
 import subprocess
 from typing import Any, Dict, List
-
 import mcp.types as types
+from pathlib import Path
 
 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': '#'
+    "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": "}",
     },
-    '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",
@@ -70,29 +49,31 @@ def execute_code_tool() -> Dict[str, Any]:
                 "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."
+                    "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."
+                    "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.",
+                    "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
-                }
+                    "maximum": 30,
+                },
             },
-            "required": ["language", "code"]
-        }
+            "required": ["language", "code"],
+        },
     }
 
+
 def execute_shell_script_tool() -> Dict[str, Any]:
     return {
         "name": "execute_shell_script",
@@ -122,47 +103,46 @@ def execute_shell_script_tool() -> Dict[str, Any]:
                 "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."
+                    "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).",
+                    "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
-                }
+                    "maximum": 600,
+                },
             },
-            "required": ["script"]
-        }
+            "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)
+        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:
+    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:
+    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:
+    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]
@@ -173,27 +153,24 @@ async def execute_code_in_temp_file(language: str, code: str, timeout: int) -> t
         os.chdir(state.allowed_directory)
 
         # Write code to temp file
-        with open(temp_file, 'w') as f:
+        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':
+            if language == "rust":
                 # Special handling for Rust
-                output_path = 'temp_script.exe'
-                compile_cmd = ['rustc', temp_file, '-o', output_path]
+                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)
+                    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
+                    return "", e.stderr.decode(), e.returncode
             else:
-                cmd = config['command'] + [temp_file]
+                cmd = config["command"] + [temp_file]
 
             # Execute code
             try:
@@ -205,18 +182,19 @@ async def execute_code_in_temp_file(language: str, code: str, timeout: int) -> t
                 )
                 return result.stdout, result.stderr, result.returncode
             except subprocess.TimeoutExpired:
-                return '', f'Execution timed out after {timeout} seconds', 124
+                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):
+            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")
@@ -230,12 +208,9 @@ async def handle_execute_code(arguments: dict) -> List[types.TextContent]:
         raise ValueError(f"Unsupported language: {language}")
 
     # Check if required command is available
-    command = LANGUAGE_CONFIGS[language]['command'][0]
+    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"
-        )]
+        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)
@@ -250,16 +225,11 @@ async def handle_execute_code(arguments: dict) -> List[types.TextContent]:
         if returncode != 0:
             result.append(f"\nProcess exited with code {returncode}")
 
-        return [types.TextContent(
-            type="text",
-            text="\n\n".join(result)
-        )]
+        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)}"
-        )]
+        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."""
@@ -270,7 +240,7 @@ async def execute_shell_script_in_temp_file(script: str, timeout: int) -> tuple[
         os.chdir(state.allowed_directory)
 
         # Write script to temp file
-        with open(temp_file, 'w') as f:
+        with open(temp_file, "w") as f:
             f.write("#!/bin/sh\n")  # Use sh for maximum compatibility
             f.write(script)
             f.flush()
@@ -280,15 +250,19 @@ async def execute_shell_script_in_temp_file(script: str, timeout: int) -> tuple[
 
         # Execute script
         try:
+            path_env = get_comprehensive_shell_paths()
+            env = os.environ.copy()
+            env["PATH"] = path_env
             result = subprocess.run(
                 ["/bin/sh", temp_file],  # Use sh explicitly for consistent behavior
                 capture_output=True,
                 timeout=timeout,
                 text=True,
+                env=env,
             )
             return result.stdout, result.stderr, result.returncode
         except subprocess.TimeoutExpired:
-            return '', f'Execution timed out after {timeout} seconds', 124
+            return "", f"Execution timed out after {timeout} seconds", 124
 
     finally:
         # Cleanup
@@ -297,6 +271,7 @@ async def execute_shell_script_in_temp_file(script: str, timeout: int) -> tuple[
         except Exception:
             pass
 
+
 async def handle_execute_shell_script(arguments: dict) -> List[types.TextContent]:
     """Handle shell script execution."""
     script = arguments.get("script")
@@ -314,13 +289,75 @@ async def handle_execute_shell_script(arguments: dict) -> List[types.TextContent
         if returncode != 0:
             result.append(f"\nScript exited with code {returncode}")
 
-        return [types.TextContent(
-            type="text",
-            text="\n\n".join(result)
-        )]
+        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)}"
-        )]
+        return [types.TextContent(type="text", text=f"Error executing shell script:\n{str(e)}")]
+
+
+def get_comprehensive_shell_paths():
+    """
+    Get PATH from shells using login mode to capture initialization files
+    """
+    shells_file = Path("/etc/shells")
+
+    if not shells_file.exists():
+        return os.environ.get("PATH", "")
+
+    # Read available shells
+    try:
+        with open(shells_file, "r") as f:
+            shells = [line.strip() for line in f if line.strip() and not line.startswith("#")]
+    except IOError:
+        return os.environ.get("PATH", "")
+
+    all_paths = []
+
+    # Get PATH from each shell as login shell
+    for shell in shells:
+        if not os.path.exists(shell):
+            continue
+
+        # Different approaches for different shells
+        commands_to_try = [
+            [shell, "--login", "-i", "-c", "echo $PATH"],
+            [shell, "-l", "-i", "-c", "echo $PATH"],
+            [shell, "--login", "-c", "echo $PATH"],
+            [shell, "-l", "-c", "echo $PATH"],
+            [shell, "-c", "echo $PATH"],
+        ]
+
+        # Try each command until one works
+        for cmd in commands_to_try:
+            try:
+                result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+                if result.returncode == 0 and result.stdout.strip():
+                    shell_path = result.stdout.strip()
+                    if shell_path and shell_path != "$PATH":
+                        all_paths.extend(shell_path.split(":"))
+                    break
+            except (subprocess.SubprocessError, subprocess.TimeoutExpired):
+                continue
+
+    # Add current PATH
+    current_path = os.environ.get("PATH", "")
+    if current_path:
+        all_paths.extend(current_path.split(":"))
+
+    # Remove duplicates while preserving order
+    return deduplicate_paths(all_paths)
+
+
+def deduplicate_paths(all_paths):
+    """
+    Remove duplicates while preserving order
+    """
+    seen = set()
+    merged_path = []
+    for path in all_paths:
+        path = path.strip()
+        if path and path not in seen and os.path.exists(path):
+            seen.add(path)
+            merged_path.append(path)
+
+    return ":".join(merged_path)

{skydeckai_code-0.1.38 → skydeckai_code-0.1.39}/src/aidd/tools/code_tools.py

@@ -5,7 +5,8 @@ import subprocess
 import json
 from datetime import datetime
 from typing import List, Dict, Any, Optional, Union, Tuple
-
+import platform
+import stat
 from mcp.types import TextContent
 from .state import state
 
@@ -65,7 +66,14 @@ def search_code_tool():
                                    "Examples: '.' for current directory, 'src' to search only within src directory. "
                                    "Default is the root of the allowed directory.",
                     "default": "."
-                }
+                },
+                "include_hidden": {
+                    "type": "boolean",
+                    "description": "Whether to include hidden files. When true, also include the hidden files like"
+                                   ".env, .config on Unix/Posix/Linux, or files with hidden attribute on Windows"
+                                   "Default is false, which exclude the hidden files from search",
+                    "default": False,
+                },
             },
             "required": ["patterns"]
         }
@@ -80,6 +88,7 @@ async def handle_search_code(arguments: dict) -> List[TextContent]:
     max_results = arguments.get("max_results", 100)
     case_sensitive = arguments.get("case_sensitive", False)
     path = arguments.get("path", ".")
+    include_hidden = arguments.get("include_hidden", False)
 
     if not patterns:
         raise ValueError("At least one pattern must be provided")
@@ -109,12 +118,12 @@ async def handle_search_code(arguments: dict) -> List[TextContent]:
                 # Use ripgrep if available for faster results
                 try:
                     result = await _search_with_ripgrep(
-                        pattern, include, exclude, max_results, case_sensitive, full_path
+                        pattern, include, exclude, max_results, case_sensitive, full_path, include_hidden
                     )
                 except (subprocess.SubprocessError, FileNotFoundError):
                     # Fallback to Python implementation if ripgrep not available
                     result = await _search_with_python(
-                        pattern, include, exclude, max_results, case_sensitive, full_path
+                        pattern, include, exclude, max_results, case_sensitive, full_path, include_hidden
                     )
 
                 # Add pattern header for multiple patterns
@@ -139,7 +148,8 @@ async def _search_with_ripgrep(
     exclude: str,
     max_results: int,
     case_sensitive: bool,
-    full_path: str
+    full_path: str,
+    include_hidden: bool
 ) -> List[TextContent]:
     """Search using ripgrep for better performance."""
     cmd = ["rg", "--line-number"]
@@ -161,6 +171,10 @@ async def _search_with_ripgrep(
     # Add max results
     cmd.extend(["--max-count", str(max_results)])
 
+    # Add hidden files
+    if include_hidden:
+        cmd.append("--hidden")
+
     # Add pattern and path
     cmd.extend([pattern, full_path])
 
@@ -247,7 +261,8 @@ async def _search_with_python(
     exclude: str,
     max_results: int,
     case_sensitive: bool,
-    full_path: str
+    full_path: str,
+    include_hidden: bool
 ) -> List[TextContent]:
     """Fallback search implementation using Python's regex and file operations."""
     # Compile the regex pattern
@@ -273,10 +288,17 @@ async def _search_with_python(
     match_count = 0
 
     # Walk the directory tree
-    for root, _, files in os.walk(full_path):
+    for root, dirs, files in os.walk(full_path):
         if match_count >= max_results:
             break
 
+        if not include_hidden:
+            # Remove hidden directories from dirs list to prevent os.walk from entering them
+            dirs[:] = [d for d in dirs if not is_hidden(os.path.join(root, d))] 
+
+            # Filter out hidden files
+            files = [f for f in files if not is_hidden(os.path.join(root, f))]
+
         for filename in files:
             if match_count >= max_results:
                 break
@@ -371,3 +393,27 @@ async def _search_with_python(
         type="text",
         text="\n".join(formatted_output)
     )]
+
+
+def is_hidden_windows(filepath: str) -> bool:
+    """Check if file/folder is hidden on Windows"""
+    try:
+        attrs = os.stat(filepath).st_file_attributes
+        return attrs & stat.FILE_ATTRIBUTE_HIDDEN
+    except (AttributeError, OSError):
+        return False
+
+
+def is_hidden_unix(name: str) -> bool:
+    """Check if file/folder is hidden on Unix-like systems (Linux/macOS)"""
+    return name.startswith('.')
+
+
+def is_hidden(filepath: str) -> bool:
+    """Cross-platform hidden file/folder detection"""
+    name = os.path.basename(filepath)
+    
+    if platform.system() == 'Windows':
+        return is_hidden_windows(filepath) or name.startswith('.')
+    else:
+        return is_hidden_unix(name)