skydeckai-code 0.1.37__py3-none-any.whl → 0.1.39__py3-none-any.whl

{skydeckai_code-0.1.37.dist-info → skydeckai_code-0.1.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skydeckai-code
-Version: 0.1.37
+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
@@ -16,6 +16,8 @@ Requires-Dist: mcp>=1.6.0
 Requires-Dist: mss>=10.0.0
 Requires-Dist: pillow>=11.1.0
 Requires-Dist: psutil>=7.0.0
+Requires-Dist: pygetwindow>=0.0.9; sys_platform == 'win32'
+Requires-Dist: pyobjc-framework-quartz>=11.0; sys_platform == 'darwin'
 Requires-Dist: requests>=2.32.3
 Requires-Dist: tree-sitter-c-sharp>=0.23.1
 Requires-Dist: tree-sitter-cpp>=0.23.4
@@ -29,12 +31,10 @@ Requires-Dist: tree-sitter-ruby>=0.23.1
 Requires-Dist: tree-sitter-rust==0.23.2
 Requires-Dist: tree-sitter-typescript>=0.23.2
 Requires-Dist: tree-sitter>=0.24.0
-Provides-Extra: macos
-Requires-Dist: pyobjc-framework-quartz>=11.0; extra == 'macos'
-Provides-Extra: windows
-Requires-Dist: pygetwindow>=0.0.9; extra == 'windows'
 Description-Content-Type: text/markdown
 
+[![MseeP.ai Security Assessment Badge](https://mseep.net/pr/skydeckai-code-badge.png)](https://mseep.ai/app/skydeckai-code)
+
 # SkyDeckAI Code
 
 An MCP server that provides a comprehensive set of tools for AI-driven development workflows. Features include file system operations, code analysis using tree-sitter for multiple programming languages, code execution, web content fetching with HTML-to-markdown conversion, multi-engine web search, code content searching, and system information retrieval. Designed to enhance AI's capability to assist in software development tasks by providing direct access to both local and remote resources.

{skydeckai_code-0.1.37.dist-info → skydeckai_code-0.1.39.dist-info}/RECORD

@@ -5,9 +5,9 @@ src/aidd/server.py,sha256=kPRyWeWkMCZjabelC65XTmzZG7yw8htMJKSfnUcKnb0,1575
 src/aidd/tools/__init__.py,sha256=j1uL7WVH3xS8JTGnpSIhaz7qkc3gcxuDyvZIYP9UztI,3731
 src/aidd/tools/base.py,sha256=wHSAaGGYWM8ECmoYd7KEcmjsZRWesNQFf3zMjCKGMcc,380
 src/aidd/tools/code_analysis.py,sha256=fDpm2o_If5PsngXzHN2-ezSkPVT0ZxivLuzmHrOAmVU,33188
-src/aidd/tools/code_execution.py,sha256=HRLUR1-q1PiCXKZV5QmTknDJKsfvPvFSWZbTpYFcv7I,13703
-src/aidd/tools/code_tools.py,sha256=DQ6N34Wbz5DwUPzt6RG7jk9HF2SsWFCFn99mencHK1c,14263
-src/aidd/tools/directory_tools.py,sha256=Hxzge_ziYw_FsjYb5yF0R0dHEdvuWRsg7WsdYDG0AUg,12971
+src/aidd/tools/code_execution.py,sha256=7HKstQ-LTjGEUn87LhowOJbd4Pq_zG0xkO-K0JJ-EFs,15513
+src/aidd/tools/code_tools.py,sha256=rJx_CMq0mB7aBJ6YcNB_6geFnjHU4OaGcXyuu909xhM,16010
+src/aidd/tools/directory_tools.py,sha256=GMG4-9iO5RfTkbhlWaW40GPKa1qujMPTN32pwxjUU4E,18052
 src/aidd/tools/file_tools.py,sha256=GYzP6WxGbV1V42FlWNSuGIyiCtRp09kwF6lOZrFtq_U,43112
 src/aidd/tools/get_active_apps_tool.py,sha256=BjLF7iXSDgyAmm_gfFgAul2Gn3iX-CNVYHM7Sh4jTAI,19427
 src/aidd/tools/get_available_windows_tool.py,sha256=OVIYhItTn9u_DftOr3vPCT-R0DOFvMEEJXA6tD6gqWQ,15952
@@ -16,10 +16,10 @@ src/aidd/tools/other_tools.py,sha256=iG3Sd2FP0M0pRv5esPBAUMvlwxTyAMDUdS77IqA_f5s
 src/aidd/tools/path_tools.py,sha256=RGoOhqP69eHJzM8tEgn_5-GRaR0gp25fd0XZIJ_RnQE,4045
 src/aidd/tools/screenshot_tool.py,sha256=NMO5B4UG8qfMEOMRd2YoOjtwz_oQ2y1UAGU22jV1yGU,46337
 src/aidd/tools/state.py,sha256=RWSw0Jfsui8FqC0xsI7Ik07tAg35hRwLHa5xGBVbiI4,1493
-src/aidd/tools/system_tools.py,sha256=H4_qveKC2HA7SIbi-j4vxA0W4jYh2wfu9A6ni5wkZyA,7249
+src/aidd/tools/system_tools.py,sha256=XgdIgKeqePZx5pj59zH7Jhs2Abn55XUf0tvKbKMVtPo,7400
 src/aidd/tools/web_tools.py,sha256=gdsj2DEVYb_oYChItK5I1ugt2w25U7IAa5kEw9q6MVg,35534
-skydeckai_code-0.1.37.dist-info/METADATA,sha256=1YGhMWLG0ftxoyHwRaO64oi5mlSpRsXW5wh0quhcHdA,31860
-skydeckai_code-0.1.37.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-skydeckai_code-0.1.37.dist-info/entry_points.txt,sha256=ZkU1spOhLEnz5MpUn4dDihVcE0DMUC6ejzbsF-eNth4,88
-skydeckai_code-0.1.37.dist-info/licenses/LICENSE,sha256=uHse04vmI6ZjW7TblegFl30X-sDyyF0-QvH8ItPca3c,10865
-skydeckai_code-0.1.37.dist-info/RECORD,,
+skydeckai_code-0.1.39.dist-info/METADATA,sha256=AwWLNrB3UMqXpsqiWYw6-ZSN8h6LRiZr_2PNt0yqfd4,31952
+skydeckai_code-0.1.39.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+skydeckai_code-0.1.39.dist-info/entry_points.txt,sha256=ZkU1spOhLEnz5MpUn4dDihVcE0DMUC6ejzbsF-eNth4,88
+skydeckai_code-0.1.39.dist-info/licenses/LICENSE,sha256=uHse04vmI6ZjW7TblegFl30X-sDyyF0-QvH8ItPca3c,10865
+skydeckai_code-0.1.39.dist-info/RECORD,,

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)

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)

src/aidd/tools/directory_tools.py

@@ -2,9 +2,9 @@ import json
 import os
 import subprocess
 from datetime import datetime
-
+import asyncio
 from mcp.types import TextContent
-
+from pathlib import Path
 from .state import state
 
 
@@ -12,12 +12,12 @@ 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.",
+        "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": {
@@ -26,10 +26,11 @@ def list_directory_tool():
                     "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"]
+            "required": ["path"],
         },
     }
 
+
 async def handle_list_directory(arguments: dict):
     from mcp.types import TextContent
 
@@ -77,29 +78,31 @@ async def handle_list_directory(arguments: dict):
     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.",
+        "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."
+                    "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"]
+            "required": ["path"],
         },
     }
 
+
 async def handle_create_directory(arguments: dict):
     """Handle creating a new directory."""
     from mcp.types import TextContent
@@ -117,9 +120,7 @@ async def handle_create_directory(arguments: dict):
 
     # 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})"
-        )
+        raise ValueError(f"Access denied: Path ({full_path}) must be within allowed directory ({state.allowed_directory})")
 
     already_exists = os.path.exists(full_path)
 
@@ -129,72 +130,48 @@ async def handle_create_directory(arguments: dict):
 
         if already_exists:
             return [TextContent(type="text", text=f"Directory already exists: {path}")]
-        return [TextContent(
-            type="text",
-            text=f"Successfully created directory: {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.",
+        "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 and only for non-hidden files, or files that are not inside hidden directory. "
+        "If you want to show the hidden files also, use commands like execute_shell_script. "
+        "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."
-                }
+                    "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.",
+                },
+                "max_depth": {
+                    "type": "integer",
+                    "description": "Max depth for traversing in case of big and deeply nested directory",
+                    "default": 3,
+                },
             },
-            "required": ["path"]
+            "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", ".")
+    max_depth = arguments.get("max_depth", 3)
 
     # Validate and get full path
     full_path = os.path.abspath(os.path.join(state.allowed_directory, path))
@@ -205,85 +182,253 @@ async def handle_directory_tree(arguments: dict):
     if not os.path.isdir(full_path):
         raise ValueError(f"Path is not a directory: {full_path}")
 
-    # Try git ls-files first
+    """
+    Idea: for git repo directory, use git ls-files to list all the files
+    So that we can avoid some gigantic directories like node_modules, build, dist
+    Else just use normal listing
+    1. Try git ls-files for this directory
+    2. If failed, identify git repo by rg and sed -> find -> python, 
+       git ls-files then add to the visited
+    3. List the remaining that is not in visited using rg -> find -> python
+    """
+    root = {"name": full_path, "type": "directory", "children": []}
+    dir_cache = {"": root}
     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
+        paths = await git_ls(Path(full_path))
+        build_tree_from_paths(root, dir_cache, paths, max_depth)
+        json_tree = json.dumps(root, indent=2)
+        return [TextContent(type="text", text=json_tree)]
+    except Exception:
         pass
-    except Exception as e:
-        # Log the error but continue with fallback
-        print(f"Error using git ls-files: {e}")
+
+    # build the tree for git repo
+    try:
+        git_repos = await find_git_repo_async(full_path)
+    except Exception:
+        git_repos = find_git_repos_python(Path(full_path))
+    for git_repo in git_repos:
+        absolute_git_repo = Path(full_path) / git_repo
+        paths = []
+        try:
+            paths = await git_ls(absolute_git_repo)
+        except Exception:
+            try:
+                paths = await scan_path_async([], absolute_git_repo)
+            except Exception:
+                paths = scan_path([], absolute_git_repo)
+        finally:
+            paths = [git_repo / path for path in paths]
+            build_tree_from_paths(root, dir_cache, paths, max_depth)
+
+    # for non-git directory, do normal scan
+    non_git_scans = []
+    try:
+        non_git_scans = await scan_path_async(git_repos, Path(full_path))
+    except Exception:
+        non_git_scans = scan_path(git_repos, Path(full_path))
+    finally:
+        build_tree_from_paths(root, dir_cache, non_git_scans, max_depth)
+        json_tree = json.dumps(root, indent=2)
+        return [TextContent(type="text", text=json_tree)]
+
+
+async def find_git_repo_async(cwd: str) -> list[Path]:
+    # ripgrep first then find
+    try:
+        cmd = r"rg --files --glob '**/.git/HEAD' --hidden | sed 's|/\.git/HEAD$|/.git|'"
+        proc = await asyncio.create_subprocess_shell(
+            cmd,
+            cwd=cwd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+
+        if proc.returncode not in [0, 1]:  # 0 = success, 1 = some files not found (normal)
+            stderr_text = stderr.decode().strip()
+            if stderr_text:  # If there's stderr content, it's likely a real error
+                raise Exception(f"Find command error: {stderr_text}")
+
+        git_dirs = stdout.decode().strip().splitlines()
+        repo_paths: list[Path] = []
+        for git_dir in git_dirs:
+            if git_dir:  # Skip empty lines
+                # Convert to Path object and get parent (removes .git)
+                repo_relative_path = Path(git_dir).parent
+                repo_paths.append(repo_relative_path)
+        return repo_paths
+
+    except Exception:
         pass
 
-    # Fallback to regular directory traversal
+    cmd = r"find . -name .git -type d ! -path '*/\.*/*'"
+    proc = await asyncio.create_subprocess_shell(
+        cmd,
+        cwd=cwd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    stdout, stderr = await proc.communicate()
+
+    if proc.returncode not in [0, 1]:  # 0 = success, 1 = some files not found (normal)
+        stderr_text = stderr.decode().strip()
+        if stderr_text:  # If there's stderr content, it's likely a real error
+            raise Exception(f"Find command error: {stderr_text}")
+
+    git_dirs = stdout.decode().strip().splitlines()
+    repo_paths: list[Path] = []
+
+    for git_dir in git_dirs:
+        if git_dir:  # Skip empty lines
+            # Convert to Path object and get parent (removes .git)
+            repo_relative_path = Path(git_dir).parent
+            repo_paths.append(repo_relative_path)
+    return repo_paths
+
+
+def find_git_repos_python(start_path: Path) -> list[Path]:
+    r"""
+    Python fallback for: find . -name .git -type d ! -path '*/\.*/*'
+
+    Finds all .git directories, excluding those inside hidden directories.
+
+    Args:
+        start_path: Starting directory (defaults to current directory)
+
+    Returns:
+        List of Path objects pointing to .git directories
+    """
+    git_dirs = []
+    start_str = str(start_path)
+
+    for root, dirs, _ in os.walk(start_str, followlinks=False):
+        # Remove hidden directories from traversal
+        dirs[:] = [d for d in dirs if not d.startswith(".")]
+
+        # Check if current directory contains .git
+        if ".git" in dirs:
+            # Calculate relative path
+            rel_root = os.path.relpath(root, start_str)
+            if rel_root == ".":
+                git_path = ".git"
+            else:
+                git_path = rel_root + "/.git"
+
+            git_dirs.append(Path(git_path))
+
+            # Remove .git from further traversal (we don't need to go inside it)
+            dirs.remove(".git")
+
+    return git_dirs
+
+
+async def git_ls(git_cwd: Path) -> list[Path]:
+    cmd = r"git ls-files"
+    proc = await asyncio.create_subprocess_shell(cmd, cwd=git_cwd, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+    stdout, stderr = await proc.communicate()
+    if proc.returncode != 0:
+        stderr_text = stderr.decode().strip()
+        raise Exception(f"Command error with status {proc.returncode}: {stderr_text}")
+
+    paths = stdout.decode().strip().splitlines()
+    paths = [Path(path) for path in paths if path]
+    return paths
+
+
+def build_tree_from_paths(root: dict, dir_cache: dict, paths: list[Path], max_depth: int):
+    paths = [path for path in paths if len(path.parts) <= max_depth]
+
+    for path in paths:
+        parts = path.parts
+        current_path = ""
+        current = root
+        n = len(parts)
+
+        for i, part in enumerate(parts):
+            if i == n - 1:
+                current["children"].append({"name": part, "type": "file"})
+            else:
+                current_path = str(Path(current_path) / part) if current_path else part
+
+                if current_path not in dir_cache:
+                    new_dir = {"name": part, "type": "directory", "children": []}
+                    current["children"].append(new_dir)
+                    dir_cache[current_path] = new_dir
+
+                current = dir_cache[current_path]
+
+
+def scan_path(ignore_paths: list[Path], cwd: Path) -> list[Path]:
+    # ignore_paths relative to cwd
+    ignore_absolute = {(cwd / ignore_path).resolve() for ignore_path in ignore_paths}
+    files: list[Path] = []
+    for root, dirs, filenames in os.walk(cwd):
+        root_path = Path(root)
+
+        # Remove hidden directories from dirs list (modifies os.walk behavior)
+        dirs[:] = [d for d in dirs if not d.startswith(".")]
+
+        # Remove ignored directories from dirs list
+        dirs[:] = [d for d in dirs if (root_path / d).resolve() not in ignore_absolute]
+
+        # Add non-hidden files
+        for filename in filenames:
+            if not filename.startswith("."):
+                file_path = root_path / filename
+                # Return path relative to cwd
+                files.append(file_path.relative_to(cwd))
+
+    return files
+
+
+async def scan_path_async(ignore_paths: list[Path], cwd: Path) -> list[Path]:
+    # try ripgrep first, then find
     try:
-        # Build the directory tree structure
-        tree = await build_directory_tree(full_path)
+        rgignore = " ".join(f"--glob '!{path}/**'" for path in ignore_paths)
+        rgcmd = rf"rg --files {rgignore} ."
+
+        proc = await asyncio.create_subprocess_shell(
+            rgcmd,
+            cwd=cwd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
 
-        # Convert to JSON with pretty printing
-        json_tree = json.dumps(tree, indent=2)
+        stdout, stderr = await proc.communicate()
 
-        return [TextContent(type="text", text=json_tree)]
-    except Exception as e:
-        raise ValueError(f"Error building directory tree: {str(e)}")
+        if proc.returncode in [0, 1]:
+            paths = []
+            for line in stdout.decode().strip().splitlines():
+                if line:
+                    paths.append(Path(line))
+            return paths
+    except Exception:
+        pass
+
+    ignore_paths += [Path("backend")]
+
+    findignore = " ".join(f"-path './{path}' -prune -o" for path in ignore_paths)
+    findcmd = f"find . {findignore} -type f ! -path '*/.*/*' ! -name '.*' -print"
+
+    proc = await asyncio.create_subprocess_shell(
+        findcmd,
+        cwd=cwd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    stdout, stderr = await proc.communicate()
+
+    if proc.returncode not in [0, 1]:  # 0 = success, 1 = some files not found (normal)
+        stderr_text = stderr.decode().strip()
+        if stderr_text:  # If there's stderr content, it's likely a real error
+            raise Exception(f"Find command error: {stderr_text}")
+
+    paths = []
+    for line in stdout.decode().strip().splitlines():
+        if line:
+            if line.startswith("./"):
+                line = line[2:]
+            if line:
+                paths.append(Path(line))
+
+    return paths

src/aidd/tools/system_tools.py

@@ -112,6 +112,9 @@ def get_system_details() -> Dict[str, Any]:
     """Gather detailed system information."""
 
     is_mac = platform.system() == "Darwin"
+    disk_total = psutil.disk_usage('/').total
+    disk_free = psutil.disk_usage('/').free
+    disk_used_percentage = (disk_total - disk_free) / disk_total * 100
 
     # System and OS Information
     system_info = {
@@ -142,7 +145,7 @@ def get_system_details() -> Dict[str, Any]:
         "disk": {
             "total": get_size(psutil.disk_usage('/').total),
             "free": get_size(psutil.disk_usage('/').free),
-            "used_percentage": f"{psutil.disk_usage('/').percent}%"
+            "used_percentage": f"{disk_used_percentage}%"
         }
     }